home *** CD-ROM | disk | FTP | other *** search
/ Zoom 1 / Zoom (1995)(Active Software, Ground Zero).iso / utils / u527.dms / u527.adf / src / 6510.asm < prev    next >
Assembly Source File  |  1995-02-22  |  57KB  |  3,093 lines
  1. *
  2. * 6510.asm - 6510-Emulation (eigener Task)
  3. *
  4. * Copyright (C) 1994-1995 by Christian Bauer
  5. *
  6.  
  7. *
  8. * Anmerkungen:
  9. * ------------
  10. *
  11. * Register d0/d1 - WICHTIG:
  12. *  - Der Emulator geht davon aus, daß die MSWs von d0 und d1 immer Null
  13. *    sind. Denn dadurch kann das C64-RAM mittels (RAMPTR,d0.l) ohne
  14. *    Vorzeichen indiziert angesprochen werden.
  15. *  - Die Makros Read#?Zero#? und Read#?Ind#? gehen zusätlich davon aus,
  16. *    daß nur das untere Byte von d0 Null ist, da diese Makros immer nur
  17. *    am Anfang eines Befehls stehen und d0 vom Next-Makro noch gelöscht
  18. *    ist
  19. *
  20. * Speicherkonfigurationen:
  21. *
  22. * $01  $a000-$bfff  $d000-$dfff  $e000-$ffff
  23. * -----------------------------------------------
  24. *  0       RAM          RAM          RAM
  25. *  1       RAM       Char-ROM        RAM
  26. *  2       RAM       Char-ROM    Kernal-ROM
  27. *  3    Basic-ROM    Char-ROM    Kernal-ROM
  28. *  4       RAM          RAM          RAM
  29. *  5       RAM          I/O          RAM
  30. *  6       RAM          I/O      Kernal-ROM
  31. *  7    Basic-ROM       I/O      Kernal-ROM
  32. *
  33. * Zugriff auf den C64-Speicher:
  34. *  - Fast alle Speicherzugriffe laufen über die ReadByte/WriteByte-Makros,
  35. *    die die eingestellte Speicherkonfiguration dadurch berücksichtigen,
  36. *    daß die oberen 8 Adreßbits als Index in eine Sprungtabelle
  37. *    (ReadTab/WriteTab) dienen, die Zeiger auf die ReadByte*/WriteByte*-
  38. *    Routinen enthalten, über die der tatsächliche Zugriff erfolgt.
  39. *    Für jede der 8 Speicherkonfigurationen existiert jeweils eine solche
  40. *    Tabelle Bei einer Änderung der Speicherkonfiguration (NewConfig)
  41. *    werden die Zeiger auf die Tabellen (RDTAB/WRTAB) geändert.
  42. *  - Das LESEN aus der Zero-Page geschieht immer direkt,
  43. *    da dort keine Register liegen ($01 wird auch im RAM abgelegt)
  44. *  - Beim Schreiben in die Zero-Page wird nur auf $00/$01 getestet,
  45. *    ansonsten direkt zugegriffen
  46. *  - Der Stack wird immer direkt angesprochen
  47. *  - Die ReadByte-Routinen dürfen nur d0-d1/a0 verändern.
  48. *    a1 enthält die Rücksprungadresse, die Routinen müssen also mit
  49. *    "jmp (a1)" enden.
  50. *  - Die WriteByte-Routinen dürfen nur d0-d1/a0-a1 verändern
  51. *
  52. * Programmzähler:
  53. *  - Aus Geschwindigkeitsgründen wird der PC durch einen 32-Bit-
  54. *    Amiga-Zeiger repräsentiert und über diesen direkt auf den
  55. *    Speicher zugegriffen (und nicht über ReadByte). Bei einem
  56. *    Sprungbefehl wird aus dem 16-Bit Sprungziel und der aktuellen
  57. *    Speicherkonfiguration die neue 32-Bit-Adresse berechnet,
  58. *    indem ähnlich zur ReadTab die oberen 8 Bit des Sprungziels
  59. *    als Index in die JumpTab verwendet werden. Die darüber aufgerufenen
  60. *    Routinen führen die Umrechnung durch.
  61. *  - Durch die Art, wie das Hauptprogramm den Speicher anfordert,
  62. *    entsprechen die unteren 16 Bit des 32-Bit-PCs immer der
  63. *    16-Bit-C64-Adresse. Das erleichtert erheblich das Ablegen des
  64. *    PC auf dem Stack, da dazu einfach nur die unteren 16 Bit
  65. *    genommen werden müssen (ansonsten müßte man je nach RAM/ROM-
  66. *    Bereich erst die jeweilige Basisadresse subtrahieren).
  67. *  - Durch diese Art der PC-Verwaltung bestehen folgende Inkompatibilitäten:
  68. *     - Es gibt keinen Wraparound über Adresse $ffff/$0000 hinweg
  69. *     - Ein Branch oder ein Hineinlaufen in einen anderen Speicherbereich
  70. *       (z.B. RAM->ROM) funktioniert nicht. Das sollte allerdings kein
  71. *       Problem darstellen.
  72. *     - Ein Sprung in den I/O-Bereich ist z.Z. nicht möglich
  73. *
  74. * Condition-Codes:
  75. *  - Die Emulation verwendet zwei Register, um die Prozessorflags zu
  76. *    speichern: RCCR und RP.
  77. *  - RCCR ist ein Abbild des 680x0-CCR und wird nach den entsprechenden
  78. *    Operationen mit "move ccr,RCCR" gelesen. Von RCCR werden nur das N-
  79. *    und das Z-Flag verwendet.
  80. *  - Die einzigen Opcodes, die V ändern, sind ADC, SBC, CLV, PLP und RTI.
  81. *    Darum wird das V-Flag nicht aus dem 680x0-V-Flag erzeugt, sondern
  82. *    gegebenenfalls von Hand gesetzt.
  83. *  - Im oberen Byte (Bit 8-15) von RP sind die 6510-Flags V,B,D und I
  84. *    in der selben Anordnung wie beim 6510 gespeichert. Das untere Byte
  85. *    enthält in Bit 0 das Carry-Flag in 6510-Interpretation (bei SBC und
  86. *    CMP/CPX/CPY inverse Bedeutung zum 680x0), das bei den entsprechenden
  87. *    Opcodes aus dem CCR gelesen (und ggf. invertiert) wird. Der Einfachheit
  88. *    halber wird immer das ganze untere Byte von CCR gelesen, da nur Bit 0
  89. *    interessant ist.
  90. *
  91. * Opcode-Ausführung:
  92. *  - Es gibt keine Fetch-Decode-Schleife, sondern jede Opcode-Routine
  93. *    enthält am Schluß den Code, der den nächsten Befehl ausführt
  94. *    ("Next"-Makro).
  95. *  - Die Verzweigung in die einzelnen Opcode-Routinen geschieht über
  96. *    eine Sprungtabelle, die OpcodeTable. Das Register OPTABPTR enthält
  97. *    einen Zeiger auf diese Tabelle (vor der Tabelle steht noch der
  98. *    Zyklenzähler, auf den so schneller zugegriffen werden kann).
  99. *
  100. * Zyklenzähler/Periodic/Interrupts:
  101. *  - Die Variable CyclesLeft (erreichbar über (OPTABPTR)) enthält die
  102. *    Anzahl Zyklen, die dem 6510 in der augenblicklichen Rasterzeile noch
  103. *    zur Verfügung stehen
  104. *  - Nach jeder Opcode-Ausführung wird dieser Zähler um die Zyklenzahl
  105. *    des gerade ausgeführten Befehls erniedrigt. Dazu wird dem Next-Makro
  106. *    die Anzahl Zyklen übergeben. Unterschreitet der Zähler Null, wird
  107. *    die Routine "Periodic" aufgerufen.
  108. *  - In dieser Routine werden die Unterroutinen von VIC und CIA
  109. *    ausgeführt, die die Aktionen für eine Rasterzeile durchführen
  110. *    (VIC (Periodic6569): Eine Bildschirmzeile aufbauen, CIA
  111. *    (Periodic6526): Timer zählen)
  112. *  - In Periodic6569 wird der Zyklenzähler neu gesetzt (der Wert hängt
  113. *    davon ab, ob eine Bad Line stattfand oder nicht)
  114. *
  115. * Interrupts:
  116. *  - Die Haupt-Interruptquellen sind VIC und CIA, daher prüft der
  117. *    Emulator das Auftreten eines Interrupts im Rahmen der Periodic-
  118. *    Routine
  119. *  - Es gibt folgende Interrupt-Möglichkeiten (Prioritäten):
  120. *     - RESET, Sprung nach ($FFFC) oder 6510-Task beenden (RESETIsEXIT-Flag)
  121. *     - NMI, Sprung nach ($FFFA)
  122. *     - VIC-IRQ, I-Flag wird geprüft, Sprung nach ($FFFE)
  123. *     - CIA-IRQ, I-Flag wird geprüft, Sprung nach ($FFFE)
  124. *  - Die Aufteilung in VIC- und CIA-IRQ erleichtert die Handhabung, wenn
  125. *    beide IRQs gleichzeitig auftreten
  126. *  - Die einzige Möglichkeit, außerhalb des Periodic einen Interrupt
  127. *    auszulösen, ist das Löschen des I-Flags, wenn ein IRQ ansteht.
  128. *    Die Opcode-Routinen für PLP, RTI und CLI enthalten deswegen besondere
  129. *    Abfragen, die ggf. in den Interrupt-Handler verzweigen.
  130. *
  131. * Erweiterungen:
  132. *  - Über den Opcode $f2 sind die 1541-Routinen implementiert. Dem Opcode
  133. *    folgt ein Byte, das die Nummer der auzurufenden Routine angibt.
  134. *
  135. * Inkompatibilitäten:
  136. *  - ($ff),Y-Adressierung liest das zweite Byte der indirekten Adresse
  137. *    aus $0100 statt $0000. Dies geschieht aus Geschwindigkeitsgründen,
  138. *    der korrekte Code ist im Makro ReadAdrIndY auskommentiert.
  139. *  - In der Verwaltung des PCs bestehen einige Ungenauigkeiten (siehe
  140. *    Abschnitt "Programmzähler")
  141. *  - RMW-Befehle sollten erst die Originaldaten und dann die geänderten
  142. *    schreiben, aber das spielt nur eine Rolle für Register wie das
  143. *    VIC-IRQFLAG-Register, das in 6569.asm deswegen speziell behandelt wird
  144. *  - Zyklen werden nur für ganze Befehle gezählt, Extra-Zyklen für
  145. *    Seitenüberschreitungen werden nicht berechnet (dies betrifft die
  146. *    Adressierungsarten xxxx,X xxxx,Y (xx),Y und die Branch-Befehle)
  147. *  - ADC und SBC im Dezimalmodus setzen die Flags nicht korrekt
  148. *  - RRA und ISB berücksichtigen das D-Flag nicht
  149. *
  150.  
  151.  
  152.         MACHINE    68020
  153.  
  154.         INCLUDE    "exec/types.i"
  155.         INCLUDE    "exec/macros.i"
  156.         INCLUDE    "exec/execbase.i"
  157.         INCLUDE    "exec/nodes.i"
  158.         INCLUDE    "dos/dos.i"
  159.         INCLUDE    "dos/dostags.i"
  160.         INCLUDE    "Frodo_rev.i"
  161. CATCOMP_NUMBERS    = 1
  162.         INCLUDE    "Strings.i"
  163.  
  164.         XREF    _SysBase
  165.         XREF    _DOSBase
  166.         XREF    _IntuitionBase
  167.  
  168.         XREF    GetString    ;Strings.o
  169.         XREF    TheLocale
  170.  
  171.         XDEF    TheRAM        ;Main.asm
  172.         XDEF    TheBasic
  173.         XDEF    TheKernal
  174.         XDEF    TheChar
  175.         XDEF    TheColor
  176.         XREF    MainTask
  177.  
  178.         XREF    ReadFrom6526A    ;6526.asm
  179.         XREF    ReadFrom6526B
  180.         XREF    WriteTo6526A
  181.         XREF    WriteTo6526B
  182.         XREF    Reset6526
  183.  
  184.         XREF    Init6569    ;6569.asm
  185.         XREF    Exit6569
  186.         XREF    ReadFrom6569
  187.         XREF    WriteTo6569
  188.         XREF    Periodic6569
  189.         XREF    AmigaToFront
  190.         XREF    EmulToFront
  191.  
  192.         XREF    ReadFrom6581    ;6581.asm
  193.         XREF    WriteTo6581
  194.         XREF    Reset6581
  195.  
  196.         XREF    IECOut        ;1541.asm
  197.         XREF    IECOutATN
  198.         XREF    IECOutSec
  199.         XREF    IECIn
  200.         XREF    IECSetATN
  201.         XREF    IECRelATN
  202.         XREF    IECTurnaround
  203.         XREF    IECRelease
  204.  
  205.         XDEF    Init6510
  206.         XDEF    Start6510
  207.         XDEF    Stop6510
  208.         XDEF    Pause6510
  209.         XDEF    Resume6510
  210.         XDEF    Localize6510
  211.         XDEF    IntIsRESET
  212.         XDEF    IntIsNMI
  213.         XDEF    IntIsVICIRQ
  214.         XDEF    IntIsCIAIRQ
  215.         XDEF    DontPause
  216.         XDEF    CyclesLeft
  217.         XDEF    CPUTask
  218.         XDEF    Peri6569Cont
  219.         XDEF    Peri6526Cont
  220.  
  221.         SECTION    "CODE",CODE
  222.  
  223.  
  224. **
  225. ** Definitionen
  226. **
  227.  
  228. ; Bitdefinitionen für RP (6510-Statusregister)
  229. CarryBit    = 0    ;Carry (nach 6510-Definition)
  230. InterruptBit    = 10    ;Interrupts abgeschaltet
  231. InterruptMask    = $0400
  232. DecimalBit    = 11    ;Dezimalmodus
  233. DecimalMask    = $0800
  234. BreakBit    = 12    ;Break-Befehl (nur auf dem Stack)
  235. BreakMask    = $1000
  236. OverflowBit    = 14    ;Arith. Überlauf
  237. OverflowMask    = $4000
  238.  
  239. ; Registerbelegung (Achtung: In 1541.asm sind ebenfalls solche
  240. ;  Definitionen, die hiermit übereinstimmen müssen!)
  241. RA        EQUR    d2    ;A
  242. RX        EQUR    d3    ;X
  243. RY        EQUR    d4    ;Y
  244. RS        EQUR    d5    ;S (16-Bit, $01xx)
  245. RCCR        EQUR    d6    ;CCR, nur N und Z
  246. RP        EQUR    d7    ;Oberes Byte: 6510-Status ohne N,Z und C.
  247.                 ;Bit #0: Carry
  248. RDTAB        EQUR    a2    ;Zeiger auf ReadByte-Sprungtabelle
  249. WRTAB        EQUR    a3    ;Zeiger auf WriteByte-Sprungtabelle
  250.                 ;256*8*4+WRTAB zeigt auf JumpTab
  251. RAMPTR        EQUR    a4    ;Zeiger auf C64-RAM
  252. RPC        EQUR    a5    ;PC (32-Bit Amiga-Adresse, untere 16 Bit
  253.                 ;    stimmen mit C64-PC überein)
  254. OPTABPTR    EQUR    a6    ;Zeiger auf die Opcode-Dispatch-Tabelle
  255.                 ; und den Zyklenzähler
  256.  
  257.  
  258. *
  259. * Makros für Speicherzugriffe und Adreßberechnungen
  260. *
  261.  
  262. ; Ein C64-Byte lesen
  263. ; -> d0.w: Adresse
  264. ; <- d0.b: Byte
  265. ReadByte    MACRO
  266.         cmp.w    #$a000,d0    ;Unterhalb von $a000 ist nur Speicher
  267.         blo    \@1$
  268.         move.w    d0,d1
  269.         lsr.w    #8,d1
  270.         lea    \@2$(pc),a1    ;Ist hier schneller, weil sonst
  271.         move.l    (RDTAB,d1.w*4),a0 ;hinter dem jmp (a0) ein bra \@2$
  272.         jmp    (a0)        ;stehen müßte
  273. \@1$        move.b    (RAMPTR,d0.l),d0
  274. \@2$
  275.         ENDM
  276.  
  277. ; Ein C64-Wort lesen (Als Makro schneller)
  278. ; -> d0.w: Adresse
  279. ; <- d0.w: Wort (Bytefolge korrigiert)
  280. ReadWord    MACRO
  281.         move.l    d0,-(sp)    ;Adresse merken
  282.         ReadByte
  283.         move.b    d0,d1
  284.         move.l    (sp)+,d0    ;Adresse zurückholen
  285.         addq.w    #1,d0        ;Nächstes Byte
  286.         move.l    d1,-(sp)    ;Lo-Byte merken
  287.         ReadByte
  288.         lsl.w    #8,d0        ;Hi-Byte richtig schieben
  289.         move.l    (sp)+,d1
  290.         move.b    d1,d0        ;Lo-Byte dazunehmen
  291.         ENDM
  292.  
  293. ; Ein C64-Byte schreiben
  294. ; -> d0.w: Adresse (16 bit)
  295. ; -> d1.b: Byte
  296. ; Adresse steht dann in a1
  297. WriteByte    MACRO
  298.         cmp.w    #$a000,d0
  299.         blo    \@1$
  300.         move.l    d0,a1
  301.         lsr.w    #8,d0
  302.         move.l    (WRTAB,d0.w*4),a0
  303.         jsr    (a0)
  304.         bra    \@2$
  305. \@1$        move.b    d1,(RAMPTR,d0.l)
  306.         cmp.b    #2,d0
  307.         bhs    \@2$
  308.         NewConfig
  309. \@2$
  310.         ENDM
  311.  
  312. ; Ein C64-Wort am PC lesen und PC erhöhen
  313. ReadPCWord    MACRO
  314.         move.w    (RPC)+,d0
  315.         rol.w    #8,d0
  316.         ENDM
  317.  
  318. ; Relative Adressierung
  319. ReadByteRel    MACRO
  320.         move.b    (RPC)+,d0
  321.         ext.w    d0
  322.         ENDM
  323.  
  324. ; Absolute Adressierung
  325. ReadAdrAbs    MACRO
  326.         ReadPCWord
  327.         ENDM
  328.  
  329. ReadByteAbs    MACRO
  330.         ReadAdrAbs
  331.         ReadByte
  332.         ENDM
  333.  
  334. ; Indirekte Adressierung
  335. ReadAdrInd    MACRO
  336.         ReadPCWord
  337.         move.l    d0,-(sp)    ;Adresse merken
  338.         ReadByte
  339.         move.b    d0,d1
  340.         move.l    (sp)+,d0    ;Adresse zurückholen
  341.         addq.b    #1,d0        ;Nächstes Byte OHNE Page-Crossing
  342.         move.l    d1,-(sp)    ;Lo-Byte merken
  343.         ReadByte
  344.         lsl.w    #8,d0        ;Hi-Byte richtig schieben
  345.         move.l    (sp)+,d1
  346.         move.b    d1,d0        ;Lo-Byte dazunehmen
  347.         ENDM
  348.  
  349. ; Zero-Page Adressierung
  350. ReadAdrZero    MACRO
  351.         move.b    (RPC)+,d0
  352.         ENDM
  353.  
  354. ReadByteZero    MACRO    ;Register
  355.         ReadAdrZero
  356.         move.b    (RAMPTR,d0.w),\1
  357.         ENDM
  358.  
  359. ; Absolut,X
  360. ReadAdrAbsX    MACRO
  361.         ReadPCWord
  362.         add.w    RX,d0
  363.         ENDM
  364.  
  365. ReadByteAbsX    MACRO
  366.         ReadAdrAbsX
  367.         ReadByte
  368.         ENDM
  369.  
  370. ; Absolut,Y
  371. ReadAdrAbsY    MACRO
  372.         ReadPCWord
  373.         add.w    RY,d0
  374.         ENDM
  375.  
  376. ReadByteAbsY    MACRO
  377.         ReadAdrAbsY
  378.         ReadByte
  379.         ENDM
  380.  
  381. ; Zero-Page,X
  382. ReadAdrZeroX    MACRO
  383.         move.b    (RPC)+,d0
  384.         add.b    RX,d0
  385.         ENDM
  386.  
  387. ReadByteZeroX    MACRO    ;Register
  388.         ReadAdrZeroX
  389.         move.b    (RAMPTR,d0.w),\1
  390.         ENDM
  391.  
  392. ; Zero-Page,Y
  393. ReadAdrZeroY    MACRO
  394.         move.b    (RPC)+,d0
  395.         add.b    RY,d0
  396.         ENDM
  397.  
  398. ReadByteZeroY    MACRO    ;Register
  399.         ReadAdrZeroY
  400.         move.b    (RAMPTR,d0.w),\1
  401.         ENDM
  402.  
  403. ; (Ind,X)
  404. ReadAdrIndX    MACRO
  405.         move.b    (RPC)+,d0
  406.         add.b    RX,d0
  407.         move.b    (RAMPTR,d0.w),d1    ;LSB lesen
  408.         addq.b    #1,d0
  409.         move.b    (RAMPTR,d0.w),d0    ;MSB lesen
  410.         lsl.w    #8,d0
  411.         move.b    d1,d0            ;LSB einfügen
  412.         ENDM
  413.  
  414. ReadByteIndX    MACRO
  415.         ReadAdrIndX
  416.         ReadByte
  417.         ENDM
  418.  
  419. ; (Ind),Y
  420. ReadAdrIndY    MACRO
  421.         move.b    (RPC)+,d0
  422.  
  423. ;(Korrekt)    move.b    (RAMPTR,d0.w),d1    ;LSB lesen
  424. ;        addq.b    #1,d0
  425. ;        move.b    (RAMPTR,d0.w),d0    ;MSB lesen
  426. ;        lsl.w    #8,d0
  427. ;        move.b    d1,d0            ;LSB einfügen
  428.  
  429.         move.w    (RAMPTR,d0.w),d0    ;(Abgekürzt)
  430.         rol.w    #8,d0            ;Geht bei ($ff),y schief
  431.  
  432.         add.w    RY,d0
  433.         ENDM
  434.  
  435. ReadByteIndY    MACRO
  436.         ReadAdrIndY
  437.         ReadByte
  438.         ENDM
  439.  
  440. ; Ein Byte (Arg1) auf den Stapel schieben
  441. PushByte    MACRO    ;Register
  442.         move.b    \1,(RAMPTR,RS.w)
  443.         subq.b    #1,RS
  444.         ENDM
  445.  
  446. ; PC auf Stack schieben
  447. PushPC        MACRO
  448.         move.w    RPC,d0
  449.         move.w    d0,d1
  450.         lsr.w    #8,d0
  451.         PushByte d0
  452.         PushByte d1
  453.         ENDM
  454.  
  455. ; PC+1 auf den Stack schieben
  456. PushPCPlus1    MACRO
  457.         move.w    RPC,d0
  458.         addq.w    #1,d0
  459.         move.w    d0,d1
  460.         lsr.w    #8,d0
  461.         PushByte    d0
  462.         PushByte    d1
  463.         ENDM
  464.  
  465. ; Status auf Stack schieben
  466. PushP        MACRO
  467.         move.w    RP,d0        ;6510-Status holen
  468.         lsr.w    #8,d0
  469.         and.b    #$5c,d0        ;V,B,D,I behalten
  470.         or.b    #$20,d0        ;1-Bit setzen
  471.         btst    #CarryBit,RP    ;C dazunehmen
  472.         beq    \@1$
  473.         or.b    #$01,d0
  474. \@1$        btst    #3,RCCR        ;N dazunehmen
  475.         beq    \@2$
  476.         or.b    #$80,d0
  477. \@2$        btst    #2,RCCR        ;Z dazunehmen
  478.         beq    \@3$
  479.         or.b    #$02,d0
  480. \@3$        PushByte d0
  481.         ENDM
  482.  
  483. ; Ein Byte vom Stapel nach Arg1 lesen
  484. PopByte        MACRO    ;Register
  485.         addq.b    #1,RS
  486.         move.b    (RAMPTR,RS.w),\1
  487.         ENDM
  488.  
  489. ; Status vom Stack holen
  490. PopP        MACRO
  491.         PopByte    d0
  492.         move    ccr,RCCR
  493.         and.b    #$08,RCCR    ;N holen
  494.         move.b    d0,RP
  495.         and.b    #$4c,RP        ;V,D,I behalten
  496.         lsl.w    #8,RP
  497.         btst    #1,d0        ;Z holen
  498.         beq    \@1$
  499.         or.b    #$04,RCCR
  500. \@1$        btst    #0,d0        ;C holen
  501.         beq    \@2$
  502.         or.b    #$01,RP
  503. \@2$
  504.         ENDM
  505.  
  506. ; PC setzen
  507. ; -> d0.w: 16-Bit-Adresse
  508. ; <- RPC.l: Amiga-Adresse
  509. Jump        MACRO
  510.         move.w    d0,d1
  511.         lsr.w    #8,d1
  512.         move.l    256*8*4(WRTAB,d1.w*4),a0
  513.         jsr    (a0)
  514.         ENDM
  515.  
  516. ; Nächsten Befehl ausführen
  517. Next        MACRO    ;Zyklenzahl
  518.     IFNE    \1
  519.         subq.w    #\1,(OPTABPTR)    ;Anzahl Zyklen abziehen
  520.         bmi    Periodic    ;Alle verbraucht: Periodic
  521.     ENDC
  522.  
  523.         moveq    #0,d0
  524.         move.b    (RPC)+,d0    ;Opcode lesen
  525.         move.l    4(OPTABPTR,d0.w*4),a0 ;Zeiger auf die Opcode-Routine holen
  526.         jmp    (a0)        ;Routine aufrufen
  527.         ENDM
  528.  
  529. ; Speicherkonfiguration anpassen
  530. NewConfig    MACRO
  531.         move.b    1(RAMPTR),d0    ;Config lesen
  532.         and.w    #7,d0        ;Relevante Bits maskieren
  533.         movem.l    (ConfigTab,pc,d0.w*8),RDTAB/WRTAB
  534.         ENDM
  535.  
  536. ; Ein C64-Byte in die Zero-Page schreiben und nächsten Befehl ausführen.
  537. ; Prüfen, ob sich die Speicherkonfiguration geändert hat.
  538. ; -> d0.w: Adresse (16 bit)
  539. ; -> Arg1: Byte
  540. WriteZeroNext    MACRO    ;Register, Zyklenzahl
  541.         move.b    \1,(RAMPTR,d0.w)
  542.         cmp.b    #2,d0
  543.         bhs    \@1$
  544.         NewConfig
  545. \@1$        Next    \2
  546.         ENDM
  547.  
  548.  
  549. **
  550. ** Emulation vorbereiten (Sprungtabellen aufbauen)
  551. **
  552.  
  553. ; ReadTabs aufbauen
  554. Init6510    lea    ReadTab0,a0        ;Alle mit RAM vorbelegen
  555.         move.w    #256*8-1,d0
  556. 1$        move.l    #ReadByteRAM,(a0)+
  557.         dbra    d0,1$
  558.  
  559.         lea    ReadTab3+160*4,a0    ;Basic-ROM
  560.         moveq    #31,d0
  561. 21$        move.l    #ReadByteBasic,(a0)+
  562.         dbra    d0,21$
  563.  
  564.         lea    ReadTab7+160*4,a0
  565.         moveq    #31,d0
  566. 22$        move.l    #ReadByteBasic,(a0)+
  567.         dbra    d0,22$
  568.  
  569.         lea    ReadTab2+224*4,a0    ;Kernal-ROM
  570.         moveq    #31,d0
  571. 31$        move.l    #ReadByteKernal,(a0)+
  572.         dbra    d0,31$
  573.  
  574.         lea    ReadTab3+224*4,a0
  575.         moveq    #31,d0
  576. 32$        move.l    #ReadByteKernal,(a0)+
  577.         dbra    d0,32$
  578.  
  579.         lea    ReadTab6+224*4,a0
  580.         moveq    #31,d0
  581. 33$        move.l    #ReadByteKernal,(a0)+
  582.         dbra    d0,33$
  583.  
  584.         lea    ReadTab7+224*4,a0
  585.         moveq    #31,d0
  586. 34$        move.l    #ReadByteKernal,(a0)+
  587.         dbra    d0,34$
  588.  
  589.         lea    ReadTab5+208*4,a0    ;I/O-Bereich
  590.         move.l    #ReadByteVIC,(a0)+
  591.         move.l    #ReadByteVIC,(a0)+
  592.         move.l    #ReadByteVIC,(a0)+
  593.         move.l    #ReadByteVIC,(a0)+
  594.         move.l    #ReadByteSID,(a0)+
  595.         move.l    #ReadByteSID,(a0)+
  596.         move.l    #ReadByteSID,(a0)+
  597.         move.l    #ReadByteSID,(a0)+
  598.         move.l    #ReadByteColor,(a0)+
  599.         move.l    #ReadByteColor,(a0)+
  600.         move.l    #ReadByteColor,(a0)+
  601.         move.l    #ReadByteColor,(a0)+
  602.         move.l    #ReadByteCIA1,(a0)+
  603.         move.l    #ReadByteCIA2,(a0)+
  604.         move.l    #ReadByteUndef,(a0)+
  605.         move.l    #ReadByteUndef,(a0)
  606.  
  607.         lea    ReadTab6+208*4,a0
  608.         move.l    #ReadByteVIC,(a0)+
  609.         move.l    #ReadByteVIC,(a0)+
  610.         move.l    #ReadByteVIC,(a0)+
  611.         move.l    #ReadByteVIC,(a0)+
  612.         move.l    #ReadByteSID,(a0)+
  613.         move.l    #ReadByteSID,(a0)+
  614.         move.l    #ReadByteSID,(a0)+
  615.         move.l    #ReadByteSID,(a0)+
  616.         move.l    #ReadByteColor,(a0)+
  617.         move.l    #ReadByteColor,(a0)+
  618.         move.l    #ReadByteColor,(a0)+
  619.         move.l    #ReadByteColor,(a0)+
  620.         move.l    #ReadByteCIA1,(a0)+
  621.         move.l    #ReadByteCIA2,(a0)+
  622.         move.l    #ReadByteUndef,(a0)+
  623.         move.l    #ReadByteUndef,(a0)
  624.  
  625.         lea    ReadTab7+208*4,a0
  626.         move.l    #ReadByteVIC,(a0)+
  627.         move.l    #ReadByteVIC,(a0)+
  628.         move.l    #ReadByteVIC,(a0)+
  629.         move.l    #ReadByteVIC,(a0)+
  630.         move.l    #ReadByteSID,(a0)+
  631.         move.l    #ReadByteSID,(a0)+
  632.         move.l    #ReadByteSID,(a0)+
  633.         move.l    #ReadByteSID,(a0)+
  634.         move.l    #ReadByteColor,(a0)+
  635.         move.l    #ReadByteColor,(a0)+
  636.         move.l    #ReadByteColor,(a0)+
  637.         move.l    #ReadByteColor,(a0)+
  638.         move.l    #ReadByteCIA1,(a0)+
  639.         move.l    #ReadByteCIA2,(a0)+
  640.         move.l    #ReadByteUndef,(a0)+
  641.         move.l    #ReadByteUndef,(a0)
  642.  
  643.         lea    ReadTab1+208*4,a0    ;Char-ROM
  644.         moveq    #15,d0
  645. 41$        move.l    #ReadByteChar,(a0)+
  646.         dbra    d0,41$
  647.  
  648.         lea    ReadTab2+208*4,a0
  649.         moveq    #15,d0
  650. 42$        move.l    #ReadByteChar,(a0)+
  651.         dbra    d0,42$
  652.  
  653.         lea    ReadTab3+208*4,a0
  654.         moveq    #15,d0
  655. 43$        move.l    #ReadByteChar,(a0)+
  656.         dbra    d0,43$
  657.  
  658. ; WriteTabs aufbauen
  659.         lea    WriteTab0,a0        ;Alle mit RAM vorbelegen
  660.         move.w    #256*8-1,d0
  661. 5$        move.l    #WriteByteRAM,(a0)+
  662.         dbra    d0,5$
  663.  
  664.         move.l    #WriteBytePage0,WriteTab0 ;Zeropage immer speziell
  665.         move.l    #WriteBytePage0,WriteTab1
  666.         move.l    #WriteBytePage0,WriteTab2
  667.         move.l    #WriteBytePage0,WriteTab3
  668.         move.l    #WriteBytePage0,WriteTab4
  669.         move.l    #WriteBytePage0,WriteTab5
  670.         move.l    #WriteBytePage0,WriteTab6
  671.         move.l    #WriteBytePage0,WriteTab7
  672.  
  673.         lea    WriteTab5+208*4,a0    ;I/O-Bereich
  674.         move.l    #WriteByteVIC,(a0)+
  675.         move.l    #WriteByteVIC,(a0)+
  676.         move.l    #WriteByteVIC,(a0)+
  677.         move.l    #WriteByteVIC,(a0)+
  678.         move.l    #WriteByteSID,(a0)+
  679.         move.l    #WriteByteSID,(a0)+
  680.         move.l    #WriteByteSID,(a0)+
  681.         move.l    #WriteByteSID,(a0)+
  682.         move.l    #WriteByteColor,(a0)+
  683.         move.l    #WriteByteColor,(a0)+
  684.         move.l    #WriteByteColor,(a0)+
  685.         move.l    #WriteByteColor,(a0)+
  686.         move.l    #WriteByteCIA1,(a0)+
  687.         move.l    #WriteByteCIA2,(a0)+
  688.         move.l    #WriteByteUndef,(a0)+
  689.         move.l    #WriteByteUndef,(a0)
  690.  
  691.         lea    WriteTab6+208*4,a0
  692.         move.l    #WriteByteVIC,(a0)+
  693.         move.l    #WriteByteVIC,(a0)+
  694.         move.l    #WriteByteVIC,(a0)+
  695.         move.l    #WriteByteVIC,(a0)+
  696.         move.l    #WriteByteSID,(a0)+
  697.         move.l    #WriteByteSID,(a0)+
  698.         move.l    #WriteByteSID,(a0)+
  699.         move.l    #WriteByteSID,(a0)+
  700.         move.l    #WriteByteColor,(a0)+
  701.         move.l    #WriteByteColor,(a0)+
  702.         move.l    #WriteByteColor,(a0)+
  703.         move.l    #WriteByteColor,(a0)+
  704.         move.l    #WriteByteCIA1,(a0)+
  705.         move.l    #WriteByteCIA2,(a0)+
  706.         move.l    #WriteByteUndef,(a0)+
  707.         move.l    #WriteByteUndef,(a0)
  708.  
  709.         lea    WriteTab7+208*4,a0
  710.         move.l    #WriteByteVIC,(a0)+
  711.         move.l    #WriteByteVIC,(a0)+
  712.         move.l    #WriteByteVIC,(a0)+
  713.         move.l    #WriteByteVIC,(a0)+
  714.         move.l    #WriteByteSID,(a0)+
  715.         move.l    #WriteByteSID,(a0)+
  716.         move.l    #WriteByteSID,(a0)+
  717.         move.l    #WriteByteSID,(a0)+
  718.         move.l    #WriteByteColor,(a0)+
  719.         move.l    #WriteByteColor,(a0)+
  720.         move.l    #WriteByteColor,(a0)+
  721.         move.l    #WriteByteColor,(a0)+
  722.         move.l    #WriteByteCIA1,(a0)+
  723.         move.l    #WriteByteCIA2,(a0)+
  724.         move.l    #WriteByteUndef,(a0)+
  725.         move.l    #WriteByteUndef,(a0)
  726.  
  727. ; JumpTabs aufbauen
  728.         lea    JumpTab0,a0        ;Alle mit RAM vorbelegen
  729.         move.w    #256*8-1,d0
  730. 6$        move.l    #JumpToRAM,(a0)+
  731.         dbra    d0,6$
  732.  
  733.         lea    JumpTab3+160*4,a0    ;Basic-ROM
  734.         moveq    #31,d0
  735. 71$        move.l    #JumpToBasic,(a0)+
  736.         dbra    d0,71$
  737.  
  738.         lea    JumpTab7+160*4,a0
  739.         moveq    #31,d0
  740. 72$        move.l    #JumpToBasic,(a0)+
  741.         dbra    d0,72$
  742.  
  743.         lea    JumpTab2+224*4,a0    ;Kernal-ROM
  744.         moveq    #31,d0
  745. 81$        move.l    #JumpToKernal,(a0)+
  746.         dbra    d0,81$
  747.  
  748.         lea    JumpTab3+224*4,a0
  749.         moveq    #31,d0
  750. 82$        move.l    #JumpToKernal,(a0)+
  751.         dbra    d0,82$
  752.  
  753.         lea    JumpTab6+224*4,a0
  754.         moveq    #31,d0
  755. 83$        move.l    #JumpToKernal,(a0)+
  756.         dbra    d0,83$
  757.  
  758.         lea    JumpTab7+224*4,a0
  759.         moveq    #31,d0
  760. 84$        move.l    #JumpToKernal,(a0)+
  761.         dbra    d0,84$
  762.  
  763.         lea    JumpTab1+208*4,a0    ;Char-ROM
  764.         moveq    #15,d0
  765. 85$        move.l    #JumpToChar,(a0)+
  766.         dbra    d0,85$
  767.  
  768.         lea    JumpTab2+208*4,a0
  769.         moveq    #15,d0
  770. 86$        move.l    #JumpToChar,(a0)+
  771.         dbra    d0,86$
  772.  
  773.         lea    JumpTab3+208*4,a0
  774.         moveq    #15,d0
  775. 87$        move.l    #JumpToChar,(a0)+
  776.         dbra    d0,87$
  777.  
  778.         lea    JumpTab5+208*4,a0    ;I/O-Bereich
  779.         moveq    #15,d0
  780. 88$        move.l    #JumpToIO,(a0)+
  781.         dbra    d0,88$
  782.  
  783.         lea    JumpTab6+208*4,a0
  784.         moveq    #15,d0
  785. 89$        move.l    #JumpToIO,(a0)+
  786.         dbra    d0,89$
  787.  
  788.         lea    JumpTab7+208*4,a0
  789.         moveq    #15,d0
  790. 810$        move.l    #JumpToIO,(a0)+
  791.         dbra    d0,810$
  792.         rts
  793.  
  794.  
  795. **
  796. ** 6510-Task starten
  797. ** Rückgabe: d0#0 = Fehler
  798. **
  799.  
  800. ; Signal einrichten
  801. Start6510    move.l    _SysBase,a6
  802.         moveq    #-1,d0
  803.         JSRLIB    AllocSignal
  804.         move.b    d0,ReadySig
  805.         moveq    #0,d1
  806.         bset    d0,d1
  807.         move.l    d1,ReadySet
  808.  
  809. ; Task starten
  810.         move.l    _DOSBase,a6
  811.         move.l    #ProcTags,d1
  812.         JSRLIB    CreateNewProc
  813.         move.l    d0,CPUProc
  814.         beq    1$
  815.  
  816. ; Auf Signal warten
  817.         move.l    _SysBase,a6
  818.         move.l    ReadySet,d0
  819.         JSRLIB    Wait
  820.         moveq    #0,d0        ;Alles OK
  821.         rts
  822.  
  823. ; Fehler aufgetreten
  824. 1$        moveq    #-1,d0
  825.         rts
  826.  
  827.  
  828. **
  829. ** 6510-Task stoppen
  830. **
  831.  
  832. ; Task stoppen
  833. Stop6510    move.l    _SysBase,a6
  834.         tst.l    CPUProc(pc)
  835.         beq    1$
  836.         st.b    RESETIsEXIT    ;EXIT-Reset auslösen
  837.         st.b    IntIsRESET
  838.         move.l    ReadySet,d0
  839.         JSRLIB    Wait
  840.  
  841. ; Signal freigeben
  842. 1$        move.b    ReadySig,d0
  843.         JSRLIB    FreeSignal
  844.         rts
  845.  
  846.  
  847. **
  848. ** 6510-Task anhalten
  849. **
  850.  
  851. Pause6510    move.l    _SysBase,a6
  852.         JSRLIB    Forbid
  853.  
  854. 2$        tst.w    DontPause(pc)    ;Pause erlaubt?
  855.         beq    1$
  856.         move.l    _DOSBase,a6    ;Nein, kurz warten und dann
  857.         moveq    #1,d1        ;nochmal probieren
  858.         JSRLIB    Delay
  859.         bra    2$
  860.  
  861. 1$        move.l    _SysBase,a6    ;OK, Task entfernen
  862.         move.l    CPUTask,a1
  863.         JSRLIB    Remove
  864.         JSRLIB    Permit
  865.         rts
  866.  
  867.  
  868. **
  869. ** 6510-Task fortsetzen
  870. **
  871.  
  872. Resume6510    move.l    _SysBase,a6
  873.         JSRLIB    Forbid
  874.         lea    TaskReady(a6),a0
  875.         move.l    CPUTask,a1    ;Task wieder einhängen
  876.         JSRLIB    Enqueue
  877.         JSRLIB    Permit
  878.         rts
  879.  
  880.  
  881. **
  882. ** Strings in Datenstrukturen lokalisieren
  883. **
  884.  
  885. GetStr        MACRO    ;Label
  886.         lea    TheLocale,a0
  887.         move.l    #\1,d0
  888.         jsr    GetString
  889.         ENDM
  890.  
  891. Localize6510    GetStr    MSG_REQTITLE
  892.         move.l    d0,IllegalOpReq+8
  893.         move.l    d0,JumpToIOReq+8
  894.  
  895.         GetStr    MSG_REQGADS3
  896.         move.l    d0,IllegalOpReq+16
  897.  
  898.         GetStr    MSG_REQGADS4
  899.         move.l    d0,JumpToIOReq+16
  900.  
  901.         GetStr    MSG_ILLEGALOP
  902.         move.l    d0,IllegalOpReq+12
  903.  
  904.         GetStr    MSG_JUMPTOIO
  905.         move.l    d0,JumpToIOReq+12
  906.         rts
  907.  
  908.  
  909. **
  910. ** 6510-Emulator
  911. **
  912. ** Register:
  913. **  d0: Scratch (Oberes Wort muß IMMER Null sein!)
  914. **  d1: Scratch (Oberes Wort muß IMMER Null sein!)
  915. **
  916.  
  917. ; Task ermitteln
  918. CPUTaskProc    move.l    _SysBase,a6
  919.         sub.l    a1,a1
  920.         JSRLIB    FindTask
  921.         move.l    d0,CPUTask
  922.  
  923. ; 6569 initialisieren
  924.         bsr    Init6569
  925.  
  926. ; Signal an den Emulator schicken
  927.         move.l    _SysBase,a6
  928.         move.l    MainTask,a1
  929.         move.l    ReadySet,d0
  930.         JSRLIB    Signal
  931.  
  932. ; Variablen initilisieren
  933.         clr.l    Interrupt
  934.         clr.b    RESETIsEXIT
  935.         clr.w    DontPause
  936.         move.w    #63,CyclesLeft
  937.  
  938. ; Speicherkonfiguration initialisieren
  939.         move.l    TheRAM,RAMPTR
  940.         move.w    #$ff07,(RAMPTR)
  941.         NewConfig
  942.  
  943. ; Register setzen
  944.         moveq    #0,d0
  945.         moveq    #0,d1
  946.         moveq    #0,RA
  947.         moveq    #0,RX
  948.         moveq    #0,RY
  949.         move.l    #$01ff,RS
  950.         moveq    #0,RCCR
  951.         move.l    #InterruptMask,RP
  952.         lea    OpcodeTable,OPTABPTR
  953.  
  954. ; Reset-Vektor lesen, PC setzen und ersten Befehl ausführen
  955.         move.w    #$fffc,d0
  956.         ReadWord
  957.         Jump
  958.         Next    0
  959.  
  960. ; Unbekannten Opcode entdeckt: Requester darstellen
  961. IllegalOp    move.w    #-1,DontPause        ;Nicht hier anhalten
  962.         movem.l    a2-a6,-(sp)
  963.  
  964.         and.w    #$00ff,d0        ;Opcode
  965.         move.w    d0,RequestStream
  966.         move.l    RPC,d0            ;und PC anzeigen
  967.         subq.w    #1,d0
  968.         move.w    d0,RequestStream+2
  969.  
  970.         bsr    AmigaToFront
  971.  
  972.         move.l    _IntuitionBase,a6
  973.         sub.l    a0,a0
  974.         lea    IllegalOpReq,a1
  975.         move.l    a0,a2
  976.         lea    RequestStream,a3
  977.         JSRLIB    EasyRequestArgs
  978.  
  979.         move.l    d0,-(sp)
  980.         bsr    EmulToFront
  981.         move.l    (sp)+,d0
  982.  
  983.         movem.l    (sp)+,a2-a6
  984.         clr.w    DontPause        ;Darf wieder angehalten werden
  985.  
  986.         tst.l    d0
  987.         beq    1$
  988.  
  989.         bsr    Reset6526    ;Reset
  990.         bsr    Reset6581
  991.         moveq    #0,d0        ;MSWs von d0 und d1
  992.         moveq    #0,d1        ; müssen Null sein
  993.         bra    HandleRESET
  994.  
  995. 1$        moveq    #0,d0        ;Weiter
  996.         moveq    #0,d1
  997.         Next    0
  998.  
  999.  
  1000. **
  1001. ** Speicherzugriff Lesen
  1002. ** In a1 steht die Rücksprungadresse
  1003. **
  1004.  
  1005. ; Lesen aus dem RAM
  1006. ReadByteRAM    move.b    (RAMPTR,d0.l),d0
  1007.         jmp    (a1)
  1008.  
  1009. ; Lesen aus dem Basic-ROM
  1010. ReadByteBasic    and.w    #$1fff,d0
  1011.         move.b    ([TheBasic,pc],d0.w),d0
  1012.         jmp    (a1)
  1013.  
  1014. ; Lesen aus einem VIC-Register
  1015. ReadByteVIC    and.w    #$3f,d0
  1016.         bsr    ReadFrom6569
  1017.         jmp    (a1)
  1018.  
  1019. ; Lesen aus einem SID-Register
  1020. ReadByteSID    and.w    #$1f,d0
  1021.         bsr    ReadFrom6581
  1022.         jmp    (a1)
  1023.  
  1024. ; Lesen aus dem Farb-RAM
  1025. ReadByteColor    and.w    #$03ff,d0
  1026.         move.b    ([TheColor,pc],d0.w),d0
  1027.         and.b    #$0f,d0
  1028.         move.b    $dff007,d1    ;Oberes Nibble ist Zufallswert
  1029.         lsl.b    #4,d1        ;Ist so zufälliger
  1030.         and.b    #$f0,d1
  1031.         or.b    d1,d0
  1032.         jmp    (a1)
  1033.  
  1034. ; Lesen aus einem CIA 1-Register
  1035. ReadByteCIA1    and.w    #$0f,d0
  1036.         bsr    ReadFrom6526A
  1037.         jmp    (a1)
  1038.  
  1039. ; Lesen aus einem CIA 2-Register
  1040. ReadByteCIA2    and.w    #$0f,d0
  1041.         bsr    ReadFrom6526B
  1042.         jmp    (a1)
  1043.  
  1044. ; Lesen einer offenen Adresse
  1045. ReadByteUndef    cmp.l    #$dfa0,d0
  1046.         bhs    1$
  1047.         move.b    $dff007,d0    ;Zufallswert
  1048.         jmp    (a1)
  1049.  
  1050. ; $dfa0-$dfff: Emulator-Identifikation
  1051. 1$        cmp.w    #$dfff,d0    ;$dfff liest abwechselnd $55/$aa
  1052.         bne    2$
  1053.         move.b    DFFFByte,d0
  1054.         not.b    DFFFByte
  1055.         jmp    (a1)        
  1056.  
  1057. 2$        cmp.w    #$dffe,d0    ;$dffe liest "F" (Frodo-Kennung)
  1058.         bne    3$
  1059.         moveq    #'F',d0
  1060.         jmp    (a1)
  1061.  
  1062. 3$        cmp.w    #$dffd,d0    ;$dffd: Version
  1063.         bne    4$
  1064.         move.b    #VERSION,d0
  1065.         jmp    (a1)
  1066.  
  1067. 4$        cmp.w    #$dffc,d0    ;$dffc: Revision
  1068.         bne    5$
  1069.         move.b    #REVISION,d0
  1070.         jmp    (a1)
  1071.  
  1072. 5$        sub.w    #$dfa0,d0    ;$dfa0-$dffb: ID-String
  1073.         move.b    IDString(pc,d0.w),d0
  1074.         jmp    (a1)
  1075.  
  1076. ; Lesen aus dem Kernal-ROM
  1077. ReadByteKernal    and.w    #$1fff,d0
  1078.         move.b    ([TheKernal,pc],d0.w),d0
  1079.         jmp    (a1)
  1080.  
  1081. ; Lesen aus dem Char-ROM
  1082. ReadByteChar    and.w    #$0fff,d0
  1083.         move.b    ([TheChar,pc],d0.w),d0
  1084.         jmp    (a1)
  1085.  
  1086.  
  1087. **
  1088. ** Speicherzugriff Schreiben
  1089. ** In a1 steht die 16-Bit-Adresse
  1090. **
  1091.  
  1092. ; Schreiben in Seite 0
  1093. WriteBytePage0    move.l    a1,d0
  1094.         move.b    d1,(RAMPTR,d0.w)
  1095.         cmp.b    #2,d0
  1096.         bhs    1$
  1097.         NewConfig
  1098. 1$        rts
  1099.  
  1100. ; Schreiben ins RAM
  1101. WriteByteRAM    move.b    d1,(RAMPTR,a1.l)
  1102.         rts
  1103.  
  1104. ; Schreiben in ein VIC-Register
  1105. WriteByteVIC    move.l    a1,d0
  1106.         and.w    #$3f,d0
  1107.         bra    WriteTo6569
  1108.  
  1109. ; Schreiben in ein SID-Register
  1110. WriteByteSID    move.l    a1,d0
  1111.         and.w    #$1f,d0
  1112.         bra    WriteTo6581
  1113.  
  1114. ; Schreiben ins Farb-RAM
  1115. WriteByteColor    move.l    a1,d0
  1116.         and.w    #$03ff,d0
  1117.         move.b    d1,([TheColor],d0.w)
  1118.         rts
  1119.  
  1120. ; Schreiben in ein CIA 1-Register
  1121. WriteByteCIA1    move.l    a1,d0
  1122.         and.w    #$0f,d0
  1123.         bra    WriteTo6526A
  1124.  
  1125. ; Schreiben in ein CIA 2-Register
  1126. WriteByteCIA2    move.l    a1,d0
  1127.         and.w    #$0f,d0
  1128.         bra    WriteTo6526B
  1129.  
  1130. ; Schreiben an einer offenen Adresse
  1131. WriteByteUndef    move.l    a1,d0
  1132.         rts
  1133.  
  1134.  
  1135. **
  1136. ** Sprungbefehle
  1137. **
  1138.  
  1139. ; Sprung ins RAM
  1140. JumpToRAM    lea    (RAMPTR,d0.l),RPC
  1141.         rts
  1142.  
  1143. ; Sprung ins Basic-ROM
  1144. JumpToBasic    move.l    TheBasic(pc),RPC
  1145.         and.w    #$1fff,d0
  1146.         add.l    d0,RPC
  1147.         rts
  1148.  
  1149. ; Sprung ins Kernal-ROM
  1150. JumpToKernal    move.l    TheKernal(pc),RPC
  1151.         and.w    #$1fff,d0
  1152.         add.l    d0,RPC
  1153.         rts
  1154.  
  1155. ; Sprung ins Char-ROM (warum sollte jemand sowas tun? Aber egal.)
  1156. JumpToChar    move.l    TheChar(pc),RPC
  1157.         and.w    #$0fff,d0
  1158.         add.l    d0,RPC
  1159.         rts
  1160.  
  1161. ; Sprung in den I/O-Bereich (in VIC-Register wird ab und zu gerne gesprungen,
  1162. ;  $de00 und das Farb-RAM sind auch sehr beliebt)
  1163. JumpToIO    move.w    #-1,DontPause        ;Nicht hier anhalten
  1164.         movem.l    a2-a6,-(sp)
  1165.  
  1166.         move.w    d0,RequestStream    ;PC anzeigen
  1167.  
  1168.         bsr    AmigaToFront
  1169.  
  1170.         move.l    _IntuitionBase,a6
  1171.         sub.l    a0,a0
  1172.         lea    JumpToIOReq,a1
  1173.         move.l    a0,a2
  1174.         lea    RequestStream,a3
  1175.         JSRLIB    EasyRequestArgs
  1176.  
  1177.         bsr    EmulToFront
  1178.  
  1179.         movem.l    (sp)+,a2-a6
  1180.         clr.w    DontPause        ;Darf wieder angehalten werden
  1181.  
  1182.         bsr    Reset6526
  1183.         bsr    Reset6581
  1184.         moveq    #0,d0            ;MSWs von d0 und d1
  1185.         moveq    #0,d1            ; müssen Null sein
  1186.  
  1187.         addq.l    #4,sp            ;Rücksprungadresse löschen
  1188.         bra    HandleRESET
  1189.  
  1190.  
  1191. **
  1192. ** Opcode-Routinen
  1193. **
  1194.  
  1195. *
  1196. * Interrupts handhaben
  1197. *
  1198.  
  1199. ; Art des Interrupt feststellen (Priorität)
  1200. HandleInt    tst.b    IntIsRESET(pc)
  1201.         bne    HandleRESET
  1202.         tst.b    IntIsNMI(pc)
  1203.         bne    HandleNMI
  1204.         tst.b    IntIsVICIRQ(pc)
  1205.         bne    HandleVICIRQ
  1206.         tst.b    IntIsCIAIRQ(pc)
  1207.         bne    HandleCIAIRQ
  1208.  
  1209. ; Kein Interrupt, nächsten Befehl ausführen
  1210. HandleIntDone    Next    0
  1211.  
  1212. ; IRQ: Interrupt-Bit testen, nach ($fffe) springen
  1213. HandleVICIRQ    btst    #InterruptBit,RP
  1214.         beq    HandleIRQ
  1215.         Next    0
  1216.  
  1217. HandleCIAIRQ    btst    #InterruptBit,RP
  1218.         beq    HandleIRQ
  1219.         Next    0
  1220.  
  1221. HandleIRQ    PushPC
  1222.         PushP
  1223.  
  1224.         or.w    #InterruptMask,RP
  1225.         move.w    #$fffe,d0    ;IRQ-Vektor
  1226.         ReadWord
  1227.         Jump
  1228.         Next    7
  1229.  
  1230. ; NMI: Nach ($fffa) springen
  1231. HandleNMI    clr.b    IntIsNMI    ;Simuliert einen flankengetriggerten Eingang
  1232.  
  1233.         PushPC
  1234.         PushP
  1235.  
  1236.         or.w    #InterruptMask,RP
  1237.         move.w    #$fffa,d0    ;NMI-Vektor
  1238.         ReadWord
  1239.         Jump
  1240.         Next    7
  1241.  
  1242. ; RESET: Emulator beenden oder nach ($fffc) springen
  1243. HandleRESET    tst.b    RESETIsEXIT(pc)    ;Beenden?
  1244.         bne    HandleEXIT
  1245.  
  1246.         clr.l    Interrupt    ;Nein, RESET
  1247.  
  1248.         cmp.l    #$c3c2cd38,$8004(RAMPTR)
  1249.         bne    1$
  1250.         cmp.b    #$30,$8008(RAMPTR)
  1251.         bne    1$
  1252.         clr.b    $8004(RAMPTR)    ;CBM80 löschen, wenn vorhanden
  1253.  
  1254. 1$        move.w    #$ff07,(RAMPTR)    ;Speicherkonfiguration initialisieren
  1255.         NewConfig
  1256.  
  1257.         move.w    #$fffc,d0    ;RESET-Vektor
  1258.         ReadWord
  1259.         Jump
  1260.         Next    0
  1261.  
  1262. ; EXIT: Signal an den Emulator schicken
  1263. HandleEXIT    bsr    Exit6569        ;6569 aufräumen
  1264.  
  1265.         move.l    _SysBase,a6
  1266.         JSRLIB    Forbid
  1267.         move.l    MainTask,a1
  1268.         move.l    ReadySet,d0
  1269.         JSRLIB    Signal
  1270.         moveq    #0,d0
  1271.         rts
  1272.  
  1273. *
  1274. * Opcodes
  1275. *
  1276.  
  1277. ; Laden
  1278. LoadA        MACRO    ;Quelle, Zyklenzahl
  1279.         move.b    \1,RA
  1280.         move    ccr,RCCR
  1281.         Next    \2
  1282.         ENDM
  1283.  
  1284. LoadX        MACRO    ;Quelle, Zyklenzahl
  1285.         move.b    \1,RX
  1286.         move    ccr,RCCR
  1287.         Next    \2
  1288.         ENDM
  1289.  
  1290. LoadY        MACRO    ;Quelle, Zyklenzahl
  1291.         move.b    \1,RY
  1292.         move    ccr,RCCR
  1293.         Next    \2
  1294.         ENDM
  1295.  
  1296. LoadAX        MACRO    ;Quelle, Zyklenzahl
  1297.         move.b    \1,RA
  1298.         move.b    RA,RX
  1299.         move    ccr,RCCR
  1300.         Next    \2
  1301.         ENDM
  1302.  
  1303. LDAImm        LoadA    (RPC)+,2
  1304.  
  1305. LDAZero        ReadAdrZero
  1306.         LoadA    (RAMPTR,d0.w),3
  1307.  
  1308. LDAZeroX    ReadAdrZeroX
  1309.         LoadA    (RAMPTR,d0.w),4
  1310.  
  1311. LDAAbs        ReadByteAbs
  1312.         LoadA    d0,4
  1313.  
  1314. LDAAbsX        ReadByteAbsX
  1315.         LoadA    d0,4
  1316.  
  1317. LDAAbsY        ReadByteAbsY
  1318.         LoadA    d0,4
  1319.  
  1320. LDAIndX        ReadByteIndX
  1321.         LoadA    d0,6
  1322.  
  1323. LDAIndY        ReadByteIndY
  1324.         LoadA    d0,5
  1325.  
  1326. LDXImm        LoadX    (RPC)+,2
  1327.  
  1328. LDXZero        ReadAdrZero
  1329.         LoadX    (RAMPTR,d0.w),3
  1330.  
  1331. LDXZeroY    ReadAdrZeroY
  1332.         LoadX    (RAMPTR,d0.w),4
  1333.  
  1334. LDXAbs        ReadByteAbs
  1335.         LoadX    d0,4
  1336.  
  1337. LDXAbsY        ReadByteAbsY
  1338.         LoadX    d0,4
  1339.  
  1340. LDYImm        LoadY    (RPC)+,2
  1341.  
  1342. LDYZero        ReadAdrZero
  1343.         LoadY    (RAMPTR,d0.w),3
  1344.  
  1345. LDYZeroX    ReadAdrZeroX
  1346.         LoadY    (RAMPTR,d0.w),4
  1347.  
  1348. LDYAbs        ReadByteAbs
  1349.         LoadY    d0,4
  1350.  
  1351. LDYAbsX        ReadByteAbsX
  1352.         LoadY    d0,4
  1353.  
  1354. LAXZero        ReadAdrZero
  1355.         LoadAX    (RAMPTR,d0.w),3
  1356.  
  1357. LAXZeroY    ReadAdrZeroY
  1358.         LoadAX    (RAMPTR,d0.w),4
  1359.  
  1360. LAXAbs        ReadByteAbs
  1361.         LoadAX    d0,4
  1362.  
  1363. LAXAbsY        ReadByteAbsY
  1364.         LoadAX    d0,4
  1365.  
  1366. LAXIndX        ReadByteIndX
  1367.         LoadAX    d0,6
  1368.  
  1369. LAXIndY        ReadByteIndY
  1370.         LoadAX    d0,5
  1371.  
  1372. ; Speichern
  1373. StoreA        MACRO    ;Zyklenzahl
  1374.         move.b    RA,d1
  1375.         WriteByte
  1376.         Next    \1
  1377.         ENDM
  1378.  
  1379. StoreAX        MACRO    ;Zyklenzahl
  1380.         move.b    RA,d1
  1381.         and.b    RX,d1
  1382.         WriteByte
  1383.         Next    \1
  1384.         ENDM
  1385.  
  1386. STAZero        ReadAdrZero
  1387.         WriteZeroNext    RA,3
  1388.  
  1389. STAZeroX    ReadAdrZeroX
  1390.         WriteZeroNext    RA,4
  1391.  
  1392. STAAbs        ReadAdrAbs
  1393.         StoreA    4
  1394.  
  1395. STAAbsX        ReadAdrAbsX
  1396.         StoreA    5
  1397.  
  1398. STAAbsY        ReadAdrAbsY
  1399.         StoreA    5
  1400.  
  1401. STAIndX        ReadAdrIndX
  1402.         StoreA    6
  1403.  
  1404. STAIndY        ReadAdrIndY
  1405.         StoreA    6
  1406.  
  1407. STXZero        ReadAdrZero
  1408.         WriteZeroNext    RX,3
  1409.  
  1410. STXZeroY    ReadAdrZeroY
  1411.         WriteZeroNext    RX,4
  1412.  
  1413. STXAbs        ReadAdrAbs
  1414.         move.b    RX,d1
  1415.         WriteByte
  1416.         Next    4
  1417.  
  1418. STYZero        ReadAdrZero
  1419.         WriteZeroNext    RY,3
  1420.  
  1421. STYZeroX    ReadAdrZeroX
  1422.         WriteZeroNext    RY,4
  1423.  
  1424. STYAbs        ReadAdrAbs
  1425.         move.b    RY,d1
  1426.         WriteByte
  1427.         Next    4
  1428.  
  1429. SAXZero        ReadAdrZero
  1430.         StoreAX    3
  1431.  
  1432. SAXZeroY    ReadAdrZeroY
  1433.         StoreAX    4
  1434.  
  1435. SAXAbs        ReadAdrAbs
  1436.         StoreAX    4
  1437.  
  1438. SAXIndX        ReadAdrIndX
  1439.         StoreAX    6
  1440.  
  1441. ; Datentransport zwischen Registern
  1442. TAX        move.b    RA,RX
  1443.         move    ccr,RCCR
  1444.         Next    2
  1445.  
  1446. TAY        move.b    RA,RY
  1447.         move    ccr,RCCR
  1448.         Next    2
  1449.  
  1450. TXA        move.b    RX,RA
  1451.         move    ccr,RCCR
  1452.         Next    2
  1453.  
  1454. TYA        move.b    RY,RA
  1455.         move    ccr,RCCR
  1456.         Next    2
  1457.  
  1458. TXS        move.b    RX,RS
  1459.         Next    2
  1460.  
  1461. TSX        move.b    RS,RX
  1462.         move    ccr,RCCR
  1463.         Next    2
  1464.  
  1465. ; Stack
  1466. PHA        PushByte RA
  1467.         Next    3
  1468.  
  1469. PLA        PopByte    RA
  1470.         move    ccr,RCCR
  1471.         Next    4
  1472.  
  1473. PHP        or.w    #BreakMask,RP    ;Prozessorfehler: Break-Flag
  1474.         PushP            ; wird auf dem Stack gesetzt
  1475.         and.w    #~BreakMask,RP
  1476.         Next    3
  1477.  
  1478. PLP        PopP
  1479.         tst.w    IntIsIRQ(pc)    ;Steht ein IRQ an?
  1480.         beq    1$
  1481.         btst    #InterruptBit,RP ;Ja, I-Flag gelöscht?
  1482.         beq    HandleIRQ    ;Ja, Interrupt auslösen
  1483. 1$        Next    4
  1484.  
  1485. ; Vergleiche
  1486. CompareA    MACRO    ;Quelle, Zyklenzahl
  1487.         cmp.b    \1,RA
  1488.         move    ccr,RCCR
  1489.         move.b    RCCR,RP        ;Carry holen und invertieren
  1490.         not.b    RP
  1491.         Next    \2
  1492.         ENDM
  1493.  
  1494. CMPImm        CompareA    (RPC)+,2
  1495.  
  1496. CMPZero        ReadAdrZero
  1497.         CompareA    (RAMPTR,d0.w),3
  1498.  
  1499. CMPZeroX    ReadAdrZeroX
  1500.         CompareA    (RAMPTR,d0.w),4
  1501.  
  1502. CMPAbs        ReadByteAbs
  1503.         CompareA    d0,4
  1504.  
  1505. CMPAbsX        ReadByteAbsX
  1506.         CompareA    d0,4
  1507.  
  1508. CMPAbsY        ReadByteAbsY
  1509.         CompareA    d0,4
  1510.  
  1511. CMPIndX        ReadByteIndX
  1512.         CompareA    d0,6
  1513.  
  1514. CMPIndY        ReadByteIndY
  1515.         CompareA    d0,5
  1516.  
  1517. CPXImm        cmp.b    (RPC)+,RX
  1518.         move    ccr,RCCR
  1519.         move.b    RCCR,RP        ;Carry holen und invertieren
  1520.         not.b    RP
  1521.         Next    2
  1522.  
  1523. CPXZero        ReadAdrZero
  1524.         cmp.b    (RAMPTR,d0.w),RX
  1525.         move    ccr,RCCR
  1526.         move.b    RCCR,RP        ;Carry holen und invertieren
  1527.         not.b    RP
  1528.         Next    3
  1529.  
  1530. CPXAbs        ReadByteAbs
  1531.         cmp.b    d0,RX
  1532.         move    ccr,RCCR
  1533.         move.b    RCCR,RP        ;Carry holen und invertieren
  1534.         not.b    RP
  1535.         Next    4
  1536.  
  1537. CPYImm        cmp.b    (RPC)+,RY
  1538.         move    ccr,RCCR
  1539.         move.b    RCCR,RP        ;Carry holen und invertieren
  1540.         not.b    RP
  1541.         Next    2
  1542.  
  1543. CPYZero        ReadAdrZero
  1544.         cmp.b    (RAMPTR,d0.w),RY
  1545.         move    ccr,RCCR
  1546.         move.b    RCCR,RP        ;Carry holen und invertieren
  1547.         not.b    RP
  1548.         Next    3
  1549.  
  1550. CPYAbs        ReadByteAbs
  1551.         cmp.b    d0,RY
  1552.         move    ccr,RCCR
  1553.         move.b    RCCR,RP        ;Carry holen und invertieren
  1554.         not.b    RP
  1555.         Next    4
  1556.  
  1557. ; Arithmetische Operationen
  1558. AdcA        MACRO    ;Zyklenzahl
  1559.         lsr.b    #1,RP        ;Carry -> X
  1560.         btst    #DecimalBit,RP
  1561.         bne    \@1$
  1562.         addx.b    d0,RA
  1563.         move    ccr,RCCR
  1564.         bvc    \@2$        ;Overflow holen
  1565.         or.w    #OverflowMask,RP
  1566.         move.b    RCCR,RP        ;Carry holen
  1567.         Next    \1
  1568. \@2$        and.w    #~OverflowMask,RP
  1569.         move.b    RCCR,RP        ;Carry holen
  1570.         Next    \1
  1571. \@1$        moveq    #0,d1        ;V und C löschen
  1572.         abcd.b    d0,RA
  1573.         move    ccr,RCCR
  1574.         bvc    \@2$        ;Overflow holen
  1575.         or.w    #OverflowMask,RP
  1576.         move.b    RCCR,RP        ;Carry holen
  1577.         Next    \1
  1578.         ENDM
  1579.  
  1580. ADCImm        move.b    (RPC)+,d0
  1581.         AdcA    2
  1582.  
  1583. ADCZero        ReadByteZero    d0
  1584.         AdcA    3
  1585.  
  1586. ADCZeroX    ReadByteZeroX    d0
  1587.         AdcA    4
  1588.  
  1589. ADCAbs        ReadByteAbs
  1590.         AdcA    4
  1591.  
  1592. ADCAbsX        ReadByteAbsX
  1593.         AdcA    4
  1594.  
  1595. ADCAbsY        ReadByteAbsY
  1596.         AdcA    4
  1597.  
  1598. ADCIndX        ReadByteIndX
  1599.         AdcA    6
  1600.  
  1601. ADCIndY        ReadByteIndY
  1602.         AdcA    5
  1603.  
  1604. SbcA        MACRO    ;Zyklenzahl
  1605.         not.b    RP
  1606.         lsr.b    #1,RP        ;Carry invertieren und nach X
  1607.         btst    #DecimalBit,RP
  1608.         bne    \@1$
  1609.         subx.b    d0,RA
  1610.         move    ccr,RCCR
  1611.         bvc    \@2$        ;Overflow holen
  1612.         or.w    #OverflowMask,RP
  1613.         move.b    RCCR,RP        ;Carry holen und invertieren
  1614.         not.b    RP
  1615.         Next    \1
  1616. \@2$        and.w    #~OverflowMask,RP
  1617.         move.b    RCCR,RP        ;Carry holen und invertieren
  1618.         not.b    RP
  1619.         Next    \1
  1620. \@1$        moveq    #0,d1        ;V und C löschen
  1621.         sbcd.b    d0,RA
  1622.         move    ccr,RCCR
  1623.         bvc    \@2$        ;Overflow holen
  1624.         or.w    #OverflowMask,RP
  1625.         move.b    RCCR,RP        ;Carry holen und invertieren
  1626.         not.b    RP
  1627.         Next    \1
  1628.         ENDM
  1629.  
  1630. SBCImm        move.b    (RPC)+,d0
  1631.         SbcA    2
  1632.  
  1633. SBCZero        ReadByteZero    d0
  1634.         SbcA    3
  1635.  
  1636. SBCZeroX    ReadByteZeroX    d0
  1637.         SbcA    4
  1638.  
  1639. SBCAbs        ReadByteAbs
  1640.         SbcA    4
  1641.  
  1642. SBCAbsX        ReadByteAbsX
  1643.         SbcA    4
  1644.  
  1645. SBCAbsY        ReadByteAbsY
  1646.         SbcA    4
  1647.  
  1648. SBCIndX        ReadByteIndX
  1649.         SbcA    6
  1650.  
  1651. SBCIndY        ReadByteIndY
  1652.         SbcA    5
  1653.  
  1654. Increment    MACRO    ;Zyklenzahl
  1655.         move.l    d0,-(sp)
  1656.         ReadByte
  1657.         addq.b    #1,d0
  1658.         move    ccr,RCCR
  1659.         move.b    d0,d1
  1660.         move.l    (sp)+,d0
  1661.         WriteByte
  1662.         Next    \1
  1663.         ENDM
  1664.  
  1665. IncrementZero    MACRO    ;Zyklenzahl
  1666.         addq.b    #1,(RAMPTR,d0.w)
  1667.         move    ccr,RCCR
  1668.         cmp.b    #2,d0
  1669.         bhs    \@1$
  1670.         NewConfig
  1671. \@1$        Next    \1
  1672.         ENDM
  1673.  
  1674. INCZero        ReadAdrZero
  1675.         IncrementZero    5
  1676.  
  1677. INCZeroX    ReadAdrZeroX
  1678.         IncrementZero    6
  1679.  
  1680. INCAbs        ReadAdrAbs
  1681.         Increment    6
  1682.  
  1683. INCAbsX        ReadAdrAbsX
  1684.         Increment    7
  1685.  
  1686. Decrement    MACRO    ;Zyklenzahl
  1687.         move.l    d0,-(sp)
  1688.         ReadByte
  1689.         subq.b    #1,d0
  1690.         move    ccr,RCCR
  1691.         move.b    d0,d1
  1692.         move.l    (sp)+,d0
  1693.         WriteByte
  1694.         Next    \1
  1695.         ENDM
  1696.  
  1697. DecrementZero    MACRO    ;Zyklenzahl
  1698.         subq.b    #1,(RAMPTR,d0.w)
  1699.         move    ccr,RCCR
  1700.         cmp.b    #2,d0
  1701.         bhs    \@1$
  1702.         NewConfig
  1703. \@1$        Next    \1
  1704.         ENDM
  1705.  
  1706. DECZero        ReadAdrZero
  1707.         DecrementZero    5
  1708.         
  1709. DECZeroX    ReadAdrZeroX
  1710.         DecrementZero    6
  1711.  
  1712. DECAbs        ReadAdrAbs
  1713.         Decrement    6
  1714.  
  1715. DECAbsX        ReadAdrAbsX
  1716.         Decrement    7
  1717.  
  1718. INX        addq.b    #1,RX
  1719.         move    ccr,RCCR
  1720.         Next    2
  1721.  
  1722. DEX        subq.b    #1,RX
  1723.         move    ccr,RCCR
  1724.         Next    2
  1725.  
  1726. INY        addq.b    #1,RY
  1727.         move    ccr,RCCR
  1728.         Next    2
  1729.  
  1730. DEY        subq.b    #1,RY
  1731.         move    ccr,RCCR
  1732.         Next    2
  1733.  
  1734. ; Logische Operationen
  1735. AndA        MACRO    ;Quelle, Zyklenzahl
  1736.         and.b    \1,RA
  1737.         move    ccr,RCCR
  1738.         Next    \2
  1739.         ENDM
  1740.  
  1741. ANDImm        AndA    (RPC)+,2
  1742.  
  1743. ANDZero        ReadAdrZero
  1744.         AndA    (RAMPTR,d0.w),3
  1745.  
  1746. ANDZeroX    ReadAdrZeroX
  1747.         AndA    (RAMPTR,d0.w),4
  1748.  
  1749. ANDAbs        ReadByteAbs
  1750.         AndA    d0,4
  1751.  
  1752. ANDAbsX        ReadByteAbsX
  1753.         AndA    d0,4
  1754.  
  1755. ANDAbsY        ReadByteAbsY
  1756.         AndA    d0,4
  1757.  
  1758. ANDIndX        ReadByteIndX
  1759.         AndA    d0,6
  1760.  
  1761. ANDIndY        ReadByteIndY
  1762.         AndA    d0,5
  1763.  
  1764. OrA        MACRO    ;Quelle, Zyklenzahl
  1765.         or.b    \1,RA
  1766.         move    ccr,RCCR
  1767.         Next    \2
  1768.         ENDM
  1769.  
  1770. ORAImm        OrA    (RPC)+,2
  1771.  
  1772. ORAZero        ReadAdrZero
  1773.         OrA    (RAMPTR,d0.w),3
  1774.  
  1775. ORAZeroX    ReadAdrZeroX
  1776.         OrA    (RAMPTR,d0.w),4
  1777.  
  1778. ORAAbs        ReadByteAbs
  1779.         OrA    d0,4
  1780.  
  1781. ORAAbsX        ReadByteAbsX
  1782.         OrA    d0,4
  1783.  
  1784. ORAAbsY        ReadByteAbsY
  1785.         OrA    d0,4
  1786.  
  1787. ORAIndX        ReadByteIndX
  1788.         OrA    d0,6
  1789.  
  1790. ORAIndY        ReadByteIndY
  1791.         OrA    d0,5
  1792.  
  1793. EorA        MACRO    ;Zyklenzahl
  1794.         eor.b    d0,RA        ;eor.b (ea),RA geht nicht
  1795.         move    ccr,RCCR    ;(Warum nicht, Motorola ?) :-(
  1796.         Next    \1
  1797.         ENDM
  1798.  
  1799. EORImm        move.b    (RPC)+,d0
  1800.         EorA    2
  1801.  
  1802. EORZero        ReadAdrZero
  1803.         move.b    (RAMPTR,d0.w),d0
  1804.         EorA    3
  1805.  
  1806. EORZeroX    ReadAdrZeroX
  1807.         move.b    (RAMPTR,d0.w),d0
  1808.         EorA    4
  1809.  
  1810. EORAbs        ReadByteAbs
  1811.         EorA    4
  1812.  
  1813. EORAbsX        ReadByteAbsX
  1814.         EorA    4
  1815.  
  1816. EORAbsY        ReadByteAbsY
  1817.         EorA    4
  1818.  
  1819. EORIndX        ReadByteIndX
  1820.         EorA    6
  1821.  
  1822. EORIndY        ReadByteIndY
  1823.         EorA    5
  1824.  
  1825. BitTest        MACRO    ;Zyklenzahl
  1826.         tst.b    d0        ;N holen
  1827.         move    ccr,RCCR
  1828.         and.w    #$1cff,RP    ;B,D,I und C behalten
  1829.  
  1830.         btst    #6,d0        ;Bit 6 -> V
  1831.         beq    \@1$
  1832.         or.w    #OverflowMask,RP
  1833.  
  1834. \@1$        and.b    RA,d0        ;A AND M -> Z
  1835.         beq    \@2$
  1836.         and.b    #$fb,RCCR
  1837.         Next    \1
  1838. \@2$        or.b    #$04,RCCR
  1839.         Next    \1
  1840.         ENDM
  1841.  
  1842. BITZero        ReadByteZero    d0
  1843.         BitTest    3
  1844.  
  1845. BITAbs        ReadByteAbs
  1846.         BitTest    4
  1847.  
  1848. ; Verschiebungen
  1849. ShiftLeft    MACRO    ;Zyklenzahl
  1850.         move.l    d0,-(sp)
  1851.         ReadByte
  1852.         add.b    d0,d0
  1853.         move    ccr,RCCR
  1854.         move.b    RCCR,RP        ;Carry holen
  1855.         move.b    d0,d1
  1856.         move.l    (sp)+,d0
  1857.         WriteByte
  1858.         Next    \1
  1859.         ENDM
  1860.  
  1861. ShiftLeftZero    MACRO    ;Zyklenzahl
  1862.         lea    (RAMPTR,d0.w),a0
  1863.         move.b    (a0),d1
  1864.         add.b    d1,d1
  1865.         move    ccr,RCCR
  1866.         move.b    RCCR,RP        ;Carry holen
  1867.         move.b    d1,(a0)
  1868.         cmp.b    #2,d0
  1869.         bhs    \@1$
  1870.         NewConfig
  1871. \@1$        Next    \1
  1872.         ENDM
  1873.  
  1874. ASLA        add.b    RA,RA
  1875.         move    ccr,RCCR
  1876.         move.b    RCCR,RP        ;Carry holen
  1877.         Next    2
  1878.  
  1879. ASLZero        ReadAdrZero
  1880.         ShiftLeftZero    5
  1881.  
  1882. ASLZeroX    ReadAdrZeroX
  1883.         ShiftLeftZero    6
  1884.  
  1885. ASLAbs        ReadAdrAbs
  1886.         ShiftLeft    6
  1887.  
  1888. ASLAbsX        ReadAdrAbsX
  1889.         ShiftLeft    7
  1890.  
  1891. ShiftRight    MACRO    ;Zyklenzahl
  1892.         move.l    d0,-(sp)
  1893.         ReadByte
  1894.         lsr.b    #1,d0
  1895.         move    ccr,RCCR
  1896.         move.b    RCCR,RP        ;Carry holen
  1897.         move.b    d0,d1
  1898.         move.l    (sp)+,d0
  1899.         WriteByte
  1900.         Next    \1
  1901.         ENDM
  1902.  
  1903. ShiftRightZero    MACRO    ;Zyklenzahl
  1904.         lea    (RAMPTR,d0.w),a0
  1905.         move.b    (a0),d1
  1906.         lsr.b    #1,d1
  1907.         move    ccr,RCCR
  1908.         move.b    RCCR,RP        ;Carry holen
  1909.         move.b    d1,(a0)
  1910.         cmp.b    #2,d0
  1911.         bhs    \@1$
  1912.         NewConfig
  1913. \@1$        Next    \1
  1914.         ENDM
  1915.  
  1916. LSRA        lsr.b    #1,RA
  1917.         move    ccr,RCCR
  1918.         move.b    RCCR,RP        ;Carry holen
  1919.         Next    2
  1920.  
  1921. LSRZero        ReadAdrZero
  1922.         ShiftRightZero    5
  1923.  
  1924. LSRZeroX    ReadAdrZeroX
  1925.         ShiftRightZero    6
  1926.  
  1927. LSRAbs        ReadAdrAbs
  1928.         ShiftRight    6
  1929.  
  1930. LSRAbsX        ReadAdrAbsX
  1931.         ShiftRight    7
  1932.  
  1933. RotateLeft    MACRO    ;Zyklenzahl
  1934.         move.l    d0,-(sp)
  1935.         ReadByte
  1936.         lsr.b    #1,RP        ;Carry -> X
  1937.         roxl.b    #1,d0
  1938.         move    ccr,RCCR
  1939.         move.b    RCCR,RP        ;Carry holen
  1940.         move.b    d0,d1
  1941.         move.l    (sp)+,d0
  1942.         WriteByte
  1943.         Next    \1
  1944.         ENDM
  1945.  
  1946. RotateLeftZero    MACRO    ;Zyklenzahl
  1947.         lea    (RAMPTR,d0.w),a0
  1948.         move.b    (a0),d1
  1949.         lsr.b    #1,RP        ;Carry -> X
  1950.         roxl.b    #1,d1
  1951.         move    ccr,RCCR
  1952.         move.b    RCCR,RP        ;Carry holen
  1953.         move.b    d1,(a0)
  1954.         cmp.b    #2,d0
  1955.         bhs    \@1$
  1956.         NewConfig
  1957. \@1$        Next    \1
  1958.         ENDM
  1959.  
  1960. ROLA        lsr.b    #1,RP        ;Carry -> X
  1961.         roxl.b    #1,RA
  1962.         move    ccr,RCCR
  1963.         move.b    RCCR,RP        ;Carry holen
  1964.         Next    2
  1965.  
  1966. ROLZero        ReadAdrZero
  1967.         RotateLeftZero    5
  1968.  
  1969. ROLZeroX    ReadAdrZeroX
  1970.         RotateLeftZero    6
  1971.  
  1972. ROLAbs        ReadAdrAbs
  1973.         RotateLeft    6
  1974.  
  1975. ROLAbsX        ReadAdrAbsX
  1976.         RotateLeft    7
  1977.  
  1978. RotateRight    MACRO    ;Zyklenzahl
  1979.         move.l    d0,-(sp)
  1980.         ReadByte
  1981.         lsr.b    #1,RP        ;Carry -> X
  1982.         roxr.b    #1,d0
  1983.         move    ccr,RCCR
  1984.         move.b    RCCR,RP        ;Carry holen
  1985.         move.b    d0,d1
  1986.         move.l    (sp)+,d0
  1987.         WriteByte
  1988.         Next    \1
  1989.         ENDM
  1990.  
  1991. RotateRightZero    MACRO    ;Zyklenzahl
  1992.         lea    (RAMPTR,d0.w),a0
  1993.         move.b    (a0),d1
  1994.         lsr.b    #1,RP        ;Carry -> X
  1995.         roxr.b    #1,d1
  1996.         move    ccr,RCCR
  1997.         move.b    RCCR,RP        ;Carry holen
  1998.         move.b    d1,(a0)
  1999.         cmp.b    #2,d0
  2000.         bhs    \@1$
  2001.         NewConfig
  2002. \@1$        Next    \1
  2003.         ENDM
  2004.  
  2005. RORA        lsr.b    #1,RP        ;Carry -> X
  2006.         roxr.b    #1,RA
  2007.         move    ccr,RCCR
  2008.         move.b    RCCR,RP        ;Carry holen
  2009.         Next    2
  2010.  
  2011. RORZero        ReadAdrZero
  2012.         RotateRightZero    5
  2013.  
  2014. RORZeroX    ReadAdrZeroX
  2015.         RotateRightZero    6
  2016.  
  2017. RORAbs        ReadAdrAbs
  2018.         RotateRight    6
  2019.  
  2020. RORAbsX        ReadAdrAbsX
  2021.         RotateRight    7
  2022.  
  2023. ; Sprünge/Verzweigungen
  2024. JMPAbs        ReadAdrAbs
  2025.         Jump
  2026.         Next    3
  2027.  
  2028. JMPInd        ReadAdrInd
  2029.         Jump
  2030.         Next    5
  2031.  
  2032. JSRAbs        PushPCPlus1
  2033.         ReadAdrAbs
  2034.         Jump
  2035.         Next    6
  2036.  
  2037. RTSImpl        PopByte    d1        ;LSB
  2038.         PopByte    d0        ;MSB
  2039.         lsl.w    #8,d0        ;schieben
  2040.         move.b    d1,d0        ;LSB dazunehmen
  2041.         addq.w    #1,d0        ;Adresse um eins erhöhen
  2042.         Jump
  2043.         Next    6
  2044.  
  2045. RTIImpl        PopP
  2046.         PopByte    d1        ;LSB
  2047.         PopByte    d0        ;MSB
  2048.         lsl.w    #8,d0        ;schieben
  2049.         move.b    d1,d0        ;LSB dazunehmen
  2050.         Jump
  2051.         tst.w    IntIsIRQ(pc)    ;Steht ein IRQ an?
  2052.         beq    1$
  2053.         btst    #InterruptBit,RP ;Ja, I-Flag gelöscht?
  2054.         beq    HandleIRQ    ;Ja, Interrupt auslösen
  2055. 1$        Next    6
  2056.  
  2057. BRK        PushPC
  2058.         or.w    #BreakMask,RP    ;Break-Flag nur auf dem Stapel setzen
  2059.         PushP
  2060.         and.w    #~BreakMask,RP
  2061.         or.w    #InterruptMask,RP
  2062.         move.w    #$fffe,d0    ;IRQ-Vektor
  2063.         ReadWord
  2064.         Jump
  2065.         Next    7
  2066.  
  2067. Branch        MACRO
  2068.         ReadByteRel
  2069.         add.w    d0,RPC        ;!! Kein Wraparound
  2070.         Next    3
  2071.         ENDM
  2072.  
  2073. BVCRel        btst    #OverflowBit,RP
  2074.         bne    BVCNot
  2075.         Branch
  2076. BVCNot        addq.l    #1,RPC
  2077.         Next    2
  2078.  
  2079. BVSRel        btst    #OverflowBit,RP
  2080.         beq    BVSNot
  2081.         Branch
  2082. BVSNot        addq.l    #1,RPC
  2083.         Next    2
  2084.  
  2085. BEQRel        btst    #2,RCCR
  2086.         beq    BEQNot
  2087.         Branch
  2088. BEQNot        addq.l    #1,RPC
  2089.         Next    2
  2090.  
  2091. BNERel        btst    #2,RCCR
  2092.         bne    BNENot
  2093.         Branch
  2094. BNENot        addq.l    #1,RPC
  2095.         Next    2
  2096.  
  2097. BPLRel        btst    #3,RCCR
  2098.         bne    BPLNot
  2099.         Branch
  2100. BPLNot        addq.l    #1,RPC
  2101.         Next    2
  2102.  
  2103. BMIRel        btst    #3,RCCR
  2104.         beq    BMINot
  2105.         Branch
  2106. BMINot        addq.l    #1,RPC
  2107.         Next    2
  2108.  
  2109. BCCRel        btst    #CarryBit,RP
  2110.         bne    BCCNot
  2111.         Branch
  2112. BCCNot        addq.l    #1,RPC
  2113.         Next    2
  2114.  
  2115. BCSRel        btst    #CarryBit,RP
  2116.         beq    BCSNot
  2117.         Branch
  2118. BCSNot        addq.l    #1,RPC
  2119.         Next    2
  2120.  
  2121. ; Statusregister
  2122. SEI        or.w    #InterruptMask,RP
  2123.         Next    2
  2124.  
  2125. CLI        and.w    #~InterruptMask,RP
  2126.         tst.w    IntIsIRQ(pc)    ;Steht ein IRQ an?
  2127.         bne    HandleIRQ    ;Ja, auslösen
  2128.         Next    2
  2129.  
  2130. CLC        clr.b    RP
  2131.         Next    2
  2132.  
  2133. SEC        st.b    RP
  2134.         Next    2
  2135.  
  2136. SED        or.w    #DecimalMask,RP
  2137.         Next    2
  2138.  
  2139. CLD        and.w    #~DecimalMask,RP
  2140.         Next    2
  2141.  
  2142. CLV        and.w    #~OverflowMask,RP
  2143.         Next    2
  2144.  
  2145. *
  2146. * Periodic: Wird über den Opcode-Fetch aufgerufen,
  2147. *  wenn der Zyklenzähler unterläuft
  2148. * Sitzt hier in der Mitte, um kurze Branches ausnutzen zu können
  2149. *
  2150.  
  2151. ; VIC und CIA aufrufen
  2152. Periodic    lea    RegStore+24,a0
  2153.         movem.w    d2-d7,-(a0)    ;Gerade Anzahl von Registern
  2154.         movem.l    a2-a3/a5,-(a0)
  2155.         bra    Periodic6569    ;Springt nach Periodic6526 und hierher zurück
  2156. Peri6526Cont    movem.l    RegStore,a2-a3/a5
  2157.         movem.w    RegStore+12,d2-d7
  2158.         move.l    TheRAM,RAMPTR    ;a4
  2159.         moveq    #0,d0
  2160.         moveq    #0,d1
  2161.  
  2162. ; Interrupt aufgetreten?
  2163.         tst.l    Interrupt(pc)
  2164.         bne    HandleInt
  2165.  
  2166. ; Nein, Nächsten Befehl ausführen
  2167.         Next    0
  2168.  
  2169.  
  2170. ; Leerbefehle
  2171. NOPImpl        Next    2
  2172.  
  2173. NOPZero        addq.w    #1,RPC
  2174.         Next    3
  2175.  
  2176. NOPZeroX    addq.w    #1,RPC
  2177.         Next    4
  2178.  
  2179. NOPAbsX
  2180. NOPAbs        addq.w    #2,RPC
  2181.         Next    4
  2182.  
  2183. ; ASL/ORA-Gruppe
  2184. ShLeftOr    MACRO    ;Zyklenzahl
  2185.         move.l    d0,-(sp)
  2186.         ReadByte
  2187.         add.b    d0,d0
  2188.         move    ccr,RCCR
  2189.         move.b    RCCR,RP        ;Carry holen
  2190.         or.b    d0,RA
  2191.         move.b    d0,d1
  2192.         move.l    (sp)+,d0
  2193.         WriteByte
  2194.         Next    \1
  2195.         ENDM
  2196.  
  2197. ShLeftOrZero    MACRO    ;Zyklenzahl
  2198.         lea    (RAMPTR,d0.w),a0
  2199.         move.b    (a0),d1
  2200.         add.b    d1,d1
  2201.         move    ccr,RCCR
  2202.         move.b    RCCR,RP        ;Carry holen
  2203.         or.b    d1,RA
  2204.         move.b    d1,(a0)
  2205.         cmp.b    #2,d0
  2206.         bhs    \@1$
  2207.         NewConfig
  2208. \@1$        Next    \1
  2209.         ENDM
  2210.  
  2211. SLOZero        ReadAdrZero
  2212.         ShLeftOrZero    5
  2213.  
  2214. SLOZeroX    ReadAdrZeroX
  2215.         ShLeftOrZero    6
  2216.  
  2217. SLOAbs        ReadAdrAbs
  2218.         ShLeftOr    6
  2219.  
  2220. SLOAbsX        ReadAdrAbsX
  2221.         ShLeftOr    7
  2222.  
  2223. SLOAbsY        ReadAdrAbsY
  2224.         ShLeftOr    7
  2225.  
  2226. SLOIndX        ReadAdrIndX
  2227.         ShLeftOr    8
  2228.  
  2229. SLOIndY        ReadAdrIndY
  2230.         ShLeftOr    8
  2231.  
  2232. ; ROL/AND-Gruppe
  2233. RoLeftAnd    MACRO    ;Zyklenzahl
  2234.         move.l    d0,-(sp)
  2235.         ReadByte
  2236.         lsr.b    #1,RP        ;Carry -> X
  2237.         roxl.b    #1,d0
  2238.         move    ccr,RCCR
  2239.         move.b    RCCR,RP        ;Carry holen
  2240.         and.b    d0,RA
  2241.         move    ccr,RCCR    ;N und Z holen
  2242.         move.b    d0,d1
  2243.         move.l    (sp)+,d0
  2244.         WriteByte
  2245.         Next    \1
  2246.         ENDM
  2247.  
  2248. RoLeftAndZero    MACRO    ;Zyklenzahl
  2249.         lea    (RAMPTR,d0.w),a0
  2250.         move.b    (a0),d1
  2251.         lsr.b    #1,RP        ;Carry -> X
  2252.         roxl.b    #1,d1
  2253.         move    ccr,RCCR
  2254.         move.b    RCCR,RP        ;Carry holen
  2255.         and.b    d1,RA
  2256.         move    ccr,RCCR    ;N und Z holen
  2257.         move.b    d1,(a0)
  2258.         cmp.b    #2,d0
  2259.         bhs    \@1$
  2260.         NewConfig
  2261. \@1$        Next    \1
  2262.         ENDM
  2263.  
  2264. RLAZero        ReadAdrZero
  2265.         RoLeftAndZero    5
  2266.  
  2267. RLAZeroX    ReadAdrZeroX
  2268.         RoLeftAndZero    6
  2269.  
  2270. RLAAbs        ReadAdrAbs
  2271.         RoLeftAnd    6
  2272.  
  2273. RLAAbsX        ReadAdrAbsX
  2274.         RoLeftAnd    7
  2275.  
  2276. RLAAbsY        ReadAdrAbsY
  2277.         RoLeftAnd    7
  2278.  
  2279. RLAIndX        ReadAdrIndX
  2280.         RoLeftAnd    8
  2281.  
  2282. RLAIndY        ReadAdrIndY
  2283.         RoLeftAnd    8
  2284.  
  2285. ; LSR/EOR-Gruppe
  2286. ShRightEor    MACRO    ;Zyklenzahl
  2287.         move.l    d0,-(sp)
  2288.         ReadByte
  2289.         lsr.b    #1,d0
  2290.         move    ccr,RCCR
  2291.         move.b    RCCR,RP        ;Carry holen
  2292.         eor.b    d0,RA
  2293.         move.b    d0,d1
  2294.         move.l    (sp)+,d0
  2295.         WriteByte
  2296.         Next    \1
  2297.         ENDM
  2298.  
  2299. ShRightEorZero    MACRO    ;Zyklenzahl
  2300.         lea    (RAMPTR,d0.w),a0
  2301.         move.b    (a0),d1
  2302.         lsr.b    #1,d1
  2303.         move    ccr,RCCR
  2304.         move.b    RCCR,RP        ;Carry holen
  2305.         eor.b    d1,RA
  2306.         move.b    d1,(a0)
  2307.         cmp.b    #2,d0
  2308.         bhs    \@1$
  2309.         NewConfig
  2310. \@1$        Next    \1
  2311.         ENDM
  2312.  
  2313. SREZero        ReadAdrZero
  2314.         ShRightEorZero    5
  2315.  
  2316. SREZeroX    ReadAdrZeroX
  2317.         ShRightEorZero    6
  2318.  
  2319. SREAbs        ReadAdrAbs
  2320.         ShRightEor    6
  2321.  
  2322. SREAbsX        ReadAdrAbsX
  2323.         ShRightEor    7
  2324.  
  2325. SREAbsY        ReadAdrAbsY
  2326.         ShRightEor    7
  2327.  
  2328. SREIndX        ReadAdrIndX
  2329.         ShRightEor    8
  2330.  
  2331. SREIndY        ReadAdrIndY
  2332.         ShRightEor    8
  2333.  
  2334. ; ROR/ADC-Gruppe
  2335. RoRightAdc    MACRO    ;Zyklenzahl
  2336.         move.l    d0,-(sp)
  2337.         ReadByte
  2338.         lsr.b    #1,RP        ;Carry -> X
  2339.         roxr.b    #1,d0
  2340.         move    ccr,RCCR
  2341.         move.b    RCCR,RP        ;Carry holen
  2342.         lsr.b    #1,RP        ;Carry -> X
  2343.         addx.b    d0,RA
  2344.         move    ccr,RCCR
  2345.         bvc    \@2$        ;Overflow holen
  2346.         or.w    #OverflowMask,RP
  2347.         bra    \@3$
  2348. \@2$        and.w    #~OverflowMask,RP
  2349. \@3$        move.b    RCCR,RP        ;Carry holen
  2350.         move.b    d0,d1
  2351.         move.l    (sp)+,d0
  2352.         WriteByte
  2353.         Next    \1
  2354.         ENDM
  2355.  
  2356. RoRightAdcZero    MACRO    ;Zyklenzahl
  2357.         lea    (RAMPTR,d0.w),a0
  2358.         move.b    (a0),d1
  2359.         lsr.b    #1,RP        ;Carry -> X
  2360.         roxr.b    #1,d1
  2361.         move    ccr,RCCR
  2362.         move.b    RCCR,RP        ;Carry holen
  2363.         lsr.b    #1,RP        ;Carry -> X
  2364.         addx.b    d1,RA
  2365.         move    ccr,RCCR
  2366.         bvc    \@2$        ;Overflow holen
  2367.         or.w    #OverflowMask,RP
  2368.         bra    \@3$
  2369. \@2$        and.w    #~OverflowMask,RP
  2370. \@3$        move.b    RCCR,RP        ;Carry holen
  2371.         move.b    d1,(a0)
  2372.         cmp.b    #2,d0
  2373.         bhs    \@1$
  2374.         NewConfig
  2375. \@1$        Next    \1
  2376.         ENDM
  2377.  
  2378. RRAZero        ReadAdrZero
  2379.         RoRightAdcZero    5
  2380.  
  2381. RRAZeroX    ReadAdrZeroX
  2382.         RoRightAdcZero    6
  2383.  
  2384. RRAAbs        ReadAdrAbs
  2385.         RoRightAdc    6
  2386.  
  2387. RRAAbsX        ReadAdrAbsX
  2388.         RoRightAdc    7
  2389.  
  2390. RRAAbsY        ReadAdrAbsY
  2391.         RoRightAdc    7
  2392.  
  2393. RRAIndX        ReadAdrIndX
  2394.         RoRightAdc    8
  2395.  
  2396. RRAIndY        ReadAdrIndY
  2397.         RoRightAdc    8
  2398.  
  2399. ; DEC/CMP-Gruppe
  2400. DecCompare    MACRO    ;Zyklenzahl
  2401.         move.l    d0,-(sp)
  2402.         ReadByte
  2403.         subq.b    #1,d0
  2404.         cmp.b    d0,RA
  2405.         move    ccr,RCCR
  2406.         move.b    RCCR,RP        ;Carry holen und invertieren
  2407.         not.b    RP
  2408.         move.b    d0,d1
  2409.         move.l    (sp)+,d0
  2410.         WriteByte
  2411.         Next    \1
  2412.         ENDM
  2413.  
  2414. DecCompareZero    MACRO    ;Zyklenzahl
  2415.         lea    (RAMPTR,d0.w),a0
  2416.         move.b    (a0),d1
  2417.         subq.b    #1,d1
  2418.         cmp.b    d1,RA
  2419.         move    ccr,RCCR
  2420.         move.b    RCCR,RP        ;Carry holen und invertieren
  2421.         not.b    RP
  2422.         move.b    d1,(a0)
  2423.         cmp.b    #2,d0
  2424.         bhs    \@1$
  2425.         NewConfig
  2426. \@1$        Next    \1
  2427.         ENDM
  2428.  
  2429. DCPZero        ReadAdrZero
  2430.         DecCompareZero    5
  2431.  
  2432. DCPZeroX    ReadAdrZeroX
  2433.         DecCompareZero    6
  2434.  
  2435. DCPAbs        ReadAdrAbs
  2436.         DecCompare    6
  2437.  
  2438. DCPAbsX        ReadAdrAbsX
  2439.         DecCompare    7
  2440.  
  2441. DCPAbsY        ReadAdrAbsY
  2442.         DecCompare    7
  2443.  
  2444. DCPIndX        ReadAdrIndX
  2445.         DecCompare    8
  2446.  
  2447. DCPIndY        ReadAdrIndY
  2448.         DecCompare    8
  2449.  
  2450. ; INC/SBC-Gruppe
  2451. IncSbc        MACRO    ;Zyklenzahl
  2452.         move.l    d0,-(sp)
  2453.         ReadByte
  2454.         addq.b    #1,d0
  2455.         not.b    RP
  2456.         lsr.b    #1,RP        ;Carry invertieren und nach X
  2457.         subx.b    d0,RA
  2458.         move    ccr,RCCR
  2459.         bvc    \@2$        ;Overflow holen
  2460.         or.w    #OverflowMask,RP
  2461.         bra    \@3$
  2462. \@2$        and.w    #~OverflowMask,RP
  2463. \@3$        move.b    RCCR,RP        ;Carry holen und invertieren
  2464.         not.b    RP
  2465.         move.b    d0,d1
  2466.         move.l    (sp)+,d0
  2467.         WriteByte
  2468.         Next    \1
  2469.         ENDM
  2470.  
  2471. IncSbcZero    MACRO    ;Zyklenzahl
  2472.         lea    (RAMPTR,d0.w),a0
  2473.         move.b    (a0),d1
  2474.         addq.b    #1,d1
  2475.         not.b    RP
  2476.         lsr.b    #1,RP        ;Carry invertieren und nach X
  2477.         subx.b    d1,RA
  2478.         move    ccr,RCCR
  2479.         bvc    \@2$        ;Overflow holen
  2480.         or.w    #OverflowMask,RP
  2481.         bra    \@3$
  2482. \@2$        and.w    #~OverflowMask,RP
  2483. \@3$        move.b    RCCR,RP        ;Carry holen und invertieren
  2484.         not.b    RP
  2485.         move.b    d1,(a0)
  2486.         cmp.b    #2,d0
  2487.         bhs    \@1$
  2488.         NewConfig
  2489. \@1$        Next    \1
  2490.         ENDM
  2491.  
  2492. ISBZero        ReadAdrZero
  2493.         IncSbcZero    5
  2494.  
  2495. ISBZeroX    ReadAdrZeroX
  2496.         IncSbcZero    6
  2497.  
  2498. ISBAbs        ReadAdrAbs
  2499.         IncSbc    6
  2500.  
  2501. ISBAbsX        ReadAdrAbsX
  2502.         IncSbc    7
  2503.  
  2504. ISBAbsY        ReadAdrAbsY
  2505.         IncSbc    7
  2506.  
  2507. ISBIndX        ReadAdrIndX
  2508.         IncSbc    8
  2509.  
  2510. ISBIndY        ReadAdrIndY
  2511.         IncSbc    8
  2512.  
  2513. ; Komplexe (undokumentierte) Funktionen
  2514. ANCImm        and.b    (RPC)+,RA    ;??? ($0b, $2b)
  2515.         move    ccr,RCCR
  2516.         smi.b    RP        ;N -> C
  2517.         Next    2
  2518.  
  2519. ASRImm        and.b    (RPC)+,RA
  2520.         lsr.b    #1,RA
  2521.         move    ccr,RCCR
  2522.         move.b    RCCR,RP
  2523.         Next    2
  2524.  
  2525. ARRImm        and.b    (RPC)+,RA
  2526.         lsr.b    #1,RP        ;Carry -> X
  2527.         roxr.b    #1,RA
  2528.         move    ccr,RCCR
  2529.         move.b    RCCR,RP        ;Carry holen
  2530.         Next    2
  2531.  
  2532. ANEImm        or.b    #$ee,RA
  2533.         and.b    (RPC)+,RA
  2534.         and.b    RX,RA
  2535.         move    ccr,RCCR
  2536.         Next    2
  2537.  
  2538. LXAImm        and.b    (RPC)+,RA
  2539.         move.b    RA,RX
  2540.         move    ccr,RCCR
  2541.         Next    2
  2542.  
  2543. LASAbsY        ReadByteAbsY        ;??? ($bb)
  2544.         and.b    RS,d0
  2545.         move.b    d0,RX
  2546.         move.b    d0,RA
  2547.         move    ccr,RCCR
  2548.         Next    4
  2549.  
  2550. SHAAbsY        ReadPCWord
  2551.         move.w    d0,d1
  2552.         lsr.w    #8,d1
  2553.         addq.b    #1,d1
  2554.         and.b    RX,d1
  2555.         and.b    RA,d1
  2556.         add.w    RY,d0
  2557.         WriteByte
  2558.         Next    5
  2559.  
  2560. SHAIndY        moveq    #0,d0
  2561.         move.b    (RPC)+,d0
  2562.         move.w    (RAMPTR,d0.w),d0    ;(Abgekürzt)
  2563.         rol.w    #8,d0            ;Geht bei ($ff),y schief
  2564.         move.w    d0,d1
  2565.         lsr.w    #8,d1
  2566.         addq.b    #1,d1
  2567.         and.b    RX,d1
  2568.         and.b    RA,d1
  2569.         add.w    RY,d0
  2570.         WriteByte
  2571.         Next    6
  2572.  
  2573. SHXAbsY        ReadPCWord
  2574.         move.w    d0,d1
  2575.         lsr.w    #8,d1
  2576.         addq.b    #1,d1
  2577.         and.b    RY,d1
  2578.         add.w    RY,d0
  2579.         WriteByte
  2580.         Next    5
  2581.  
  2582. SHYAbsX        ReadPCWord
  2583.         move.w    d0,d1
  2584.         lsr.w    #8,d1
  2585.         addq.b    #1,d1
  2586.         and.b    RX,d1
  2587.         add.w    RX,d0
  2588.         WriteByte
  2589.         Next    5
  2590.  
  2591. SHSAbsY        move.b    RA,RS
  2592.         and.b    RX,RS
  2593.         ReadPCWord
  2594.         move.w    d0,d1
  2595.         lsr.w    #8,d1
  2596.         addq.b    #1,d1
  2597.         and.b    RS,d1
  2598.         WriteByte
  2599.         Next    5
  2600.  
  2601. SBXImm        and.b    RA,RX
  2602.         sub.b    (RPC)+,RX
  2603.         move    ccr,RCCR
  2604.         move.b    RCCR,RP        ;Carry holen und invertieren
  2605.         not.b    RP
  2606.         Next    2
  2607.  
  2608. *
  2609. * Patches
  2610. *
  2611.  
  2612. OpIEC        move.w    #-1,DontPause    ;Nicht hier anhalten
  2613.         move.b    (RPC)+,d0    ;Selektor holen
  2614.         beq    OpIECOut
  2615.         cmp.b    #1,d0
  2616.         beq    OpIECOutATN
  2617.         cmp.b    #2,d0
  2618.         beq    OpIECOutSec
  2619.         cmp.b    #3,d0
  2620.         beq    OpIECIn
  2621.         cmp.b    #4,d0
  2622.         beq    OpIECSetATN
  2623.         cmp.b    #5,d0
  2624.         beq    OpIECRelATN
  2625.         cmp.b    #6,d0
  2626.         beq    OpIECTurnaround
  2627.         cmp.b    #7,d0
  2628.         beq    OpIECRelease
  2629.         clr.w    DontPause
  2630.         Next    0
  2631.  
  2632. OpIECOut    move.b    $95(RAMPTR),d0    ;Auszugebendes Byte holen
  2633.         move.b    $a3(RAMPTR),d1    ;EOI-Flag holen
  2634.         bsr    IECOut
  2635.         bra    IECSetST
  2636.  
  2637. OpIECOutATN    move.b    $95(RAMPTR),d0    ;Auszugebendes Byte holen
  2638.         bsr    IECOutATN
  2639.         bra    IECSetST
  2640.  
  2641. OpIECOutSec    move.b    $95(RAMPTR),d0    ;Auszugebendes Byte holen
  2642.         bsr    IECOutSec
  2643.         bra    IECSetST
  2644.  
  2645. OpIECIn        bsr    IECIn
  2646.         move.b    d1,RA        ;Byte in den Akku
  2647.         move    ccr,RCCR    ;Flags entsprechend setzen
  2648.         bra    IECSetST
  2649.  
  2650. OpIECSetATN    bsr    IECSetATN
  2651.         moveq    #0,d0        ;MSWs von d0 und d1 löschen
  2652.         moveq    #0,d1
  2653.         clr.w    DontPause
  2654.         move.w    #$edfb,d0    ;Nach $edfb springen
  2655.         Jump
  2656.         Next    0
  2657.  
  2658. OpIECRelATN    bsr    IECRelATN
  2659.         bra    IECReturn
  2660.  
  2661. OpIECTurnaround    bsr    IECTurnaround
  2662.         bra    IECReturn
  2663.  
  2664. OpIECRelease    bsr    IECRelease
  2665.         bra    IECReturn
  2666.  
  2667. IECSetST    or.b    d0,$90(RAMPTR)    ;Status setzen
  2668.         clr.b    RP        ;Carry löschen
  2669. IECReturn    moveq    #0,d0        ;MSWs von d0 und d1 löschen
  2670.         moveq    #0,d1
  2671.         clr.w    DontPause
  2672.         bra    RTSImpl        ;RTS ausführen
  2673.  
  2674.  
  2675. **
  2676. ** Konstanten
  2677. **
  2678.  
  2679. ; Strings
  2680. CPUTaskName    dc.b    "6510",0
  2681. TimerIntName    dc.b    "Frodo Timer Int",0
  2682.  
  2683. IDString    dc.b    "FRODO V1.3",13
  2684.         dc.b    "(C)1994-1995 CHRISTIAN BAUER",0
  2685.         ds.b    64    ;Muß mind. 92 Zeichen lang sein
  2686.         CNOP    0,4
  2687.  
  2688.  
  2689. *
  2690. * Speicherkonfigurationstabelle
  2691. *
  2692.  
  2693. ; Diese Tabelle enthält für alle 8 Speicherkonfigurationen
  2694. ; die Zeiger auf die zugehörigen Read- und WriteTabs
  2695.         CNOP    0,4
  2696. ConfigTab    dc.l    ReadTab0,WriteTab0
  2697.         dc.l    ReadTab1,WriteTab1
  2698.         dc.l    ReadTab2,WriteTab2
  2699.         dc.l    ReadTab3,WriteTab3
  2700.         dc.l    ReadTab4,WriteTab4
  2701.         dc.l    ReadTab5,WriteTab5
  2702.         dc.l    ReadTab6,WriteTab6
  2703.         dc.l    ReadTab7,WriteTab7
  2704.  
  2705.  
  2706. *
  2707. * Opcode Dispatch Table
  2708. * "*" bezeichnet einen undokumentierten Opcode
  2709. *
  2710.  
  2711.         CNOP    0,4
  2712. OpcodeTable
  2713. CyclesLeft    dc.w    0    ;Anzahl zur Verfügung stehender CPU-Zyklen
  2714.                 ; bis zum nächsten Periodic
  2715.         dc.w    0
  2716.         dc.l    BRK        ;$00
  2717.         dc.l    ORAIndX
  2718.         dc.l    IllegalOp
  2719.         dc.l    SLOIndX        ;*
  2720.         dc.l    NOPZero        ;*
  2721.         dc.l    ORAZero
  2722.         dc.l    ASLZero
  2723.         dc.l    SLOZero        ;*
  2724.  
  2725.         dc.l    PHP        ;$08
  2726.         dc.l    ORAImm
  2727.         dc.l    ASLA
  2728.         dc.l    ANCImm        ;*
  2729.         dc.l    NOPAbs        ;*
  2730.         dc.l    ORAAbs
  2731.         dc.l    ASLAbs
  2732.         dc.l    SLOAbs        ;*
  2733.  
  2734.         dc.l    BPLRel        ;$10
  2735.         dc.l    ORAIndY
  2736.         dc.l    IllegalOp
  2737.         dc.l    SLOIndY        ;*
  2738.         dc.l    NOPZeroX    ;*
  2739.         dc.l    ORAZeroX
  2740.         dc.l    ASLZeroX
  2741.         dc.l    SLOZeroX    ;*
  2742.  
  2743.         dc.l    CLC        ;$18
  2744.         dc.l    ORAAbsY
  2745.         dc.l    NOPImpl        ;*
  2746.         dc.l    SLOAbsY        ;*
  2747.         dc.l    NOPAbsX        ;*
  2748.         dc.l    ORAAbsX
  2749.         dc.l    ASLAbsX
  2750.         dc.l    SLOAbsX
  2751.  
  2752.         dc.l    JSRAbs        ;$20
  2753.         dc.l    ANDIndX
  2754.         dc.l    IllegalOp
  2755.         dc.l    RLAIndX        ;*
  2756.         dc.l    BITZero
  2757.         dc.l    ANDZero
  2758.         dc.l    ROLZero
  2759.         dc.l    RLAZero        ;*
  2760.  
  2761.         dc.l    PLP        ;$28
  2762.         dc.l    ANDImm
  2763.         dc.l    ROLA
  2764.         dc.l    ANCImm        ;*
  2765.         dc.l    BITAbs
  2766.         dc.l    ANDAbs
  2767.         dc.l    ROLAbs
  2768.         dc.l    RLAAbs        ;*
  2769.  
  2770.         dc.l    BMIRel        ;$30
  2771.         dc.l    ANDIndY
  2772.         dc.l    IllegalOp
  2773.         dc.l    RLAIndY        ;*
  2774.         dc.l    NOPZeroX    ;*
  2775.         dc.l    ANDZeroX
  2776.         dc.l    ROLZeroX
  2777.         dc.l    RLAZeroX    ;*
  2778.  
  2779.         dc.l    SEC        ;$38
  2780.         dc.l    ANDAbsY
  2781.         dc.l    NOPImpl        ;*
  2782.         dc.l    RLAAbsY        ;*
  2783.         dc.l    NOPAbsX        ;*
  2784.         dc.l    ANDAbsX
  2785.         dc.l    ROLAbsX
  2786.         dc.l    RLAAbsX        ;*
  2787.  
  2788.         dc.l    RTIImpl        ;$40
  2789.         dc.l    EORIndX
  2790.         dc.l    IllegalOp
  2791.         dc.l    SREIndX        ;*
  2792.         dc.l    NOPZero        ;*
  2793.         dc.l    EORZero
  2794.         dc.l    LSRZero
  2795.         dc.l    SREZero        ;*
  2796.  
  2797.         dc.l    PHA        ;$48
  2798.         dc.l    EORImm
  2799.         dc.l    LSRA
  2800.         dc.l    ASRImm        ;*
  2801.         dc.l    JMPAbs
  2802.         dc.l    EORAbs
  2803.         dc.l    LSRAbs
  2804.         dc.l    SREAbs        ;*
  2805.  
  2806.         dc.l    BVCRel        ;$50
  2807.         dc.l    EORIndY
  2808.         dc.l    IllegalOp
  2809.         dc.l    SREIndY        ;*
  2810.         dc.l    NOPZeroX    ;*
  2811.         dc.l    EORZeroX
  2812.         dc.l    LSRZeroX
  2813.         dc.l    SREZeroX    ;*
  2814.  
  2815.         dc.l    CLI        ;$58
  2816.         dc.l    EORAbsY
  2817.         dc.l    NOPImpl        ;*
  2818.         dc.l    SREAbsY        ;*
  2819.         dc.l    NOPAbsX        ;*
  2820.         dc.l    EORAbsX
  2821.         dc.l    LSRAbsX
  2822.         dc.l    SREAbsX        ;*
  2823.  
  2824.         dc.l    RTSImpl        ;$60
  2825.         dc.l    ADCIndX
  2826.         dc.l    IllegalOp
  2827.         dc.l    RRAIndX        ;*
  2828.         dc.l    NOPZero        ;*
  2829.         dc.l    ADCZero
  2830.         dc.l    RORZero
  2831.         dc.l    RRAZero        ;*
  2832.  
  2833.         dc.l    PLA        ;$68
  2834.         dc.l    ADCImm
  2835.         dc.l    RORA
  2836.         dc.l    ARRImm        ;*
  2837.         dc.l    JMPInd
  2838.         dc.l    ADCAbs
  2839.         dc.l    RORAbs
  2840.         dc.l    RRAAbs        ;*
  2841.  
  2842.         dc.l    BVSRel        ;$70
  2843.         dc.l    ADCIndY
  2844.         dc.l    IllegalOp
  2845.         dc.l    RRAIndY        ;*
  2846.         dc.l    NOPZeroX    ;*
  2847.         dc.l    ADCZeroX
  2848.         dc.l    RORZeroX
  2849.         dc.l    RRAZeroX    ;*
  2850.  
  2851.         dc.l    SEI        ;$78
  2852.         dc.l    ADCAbsY
  2853.         dc.l    NOPImpl        ;*
  2854.         dc.l    RRAAbsY        ;*
  2855.         dc.l    NOPAbsX        ;*
  2856.         dc.l    ADCAbsX
  2857.         dc.l    RORAbsX
  2858.         dc.l    RRAAbsX        ;*
  2859.  
  2860.         dc.l    NOPZero        ;* $80
  2861.         dc.l    STAIndX
  2862.         dc.l    NOPZero        ;*
  2863.         dc.l    SAXIndX        ;*
  2864.         dc.l    STYZero
  2865.         dc.l    STAZero
  2866.         dc.l    STXZero
  2867.         dc.l    SAXZero        ;*
  2868.  
  2869.         dc.l    DEY        ;$88
  2870.         dc.l    NOPZero        ;*
  2871.         dc.l    TXA
  2872.         dc.l    ANEImm        ;*
  2873.         dc.l    STYAbs
  2874.         dc.l    STAAbs
  2875.         dc.l    STXAbs
  2876.         dc.l    SAXAbs        ;*
  2877.  
  2878.         dc.l    BCCRel        ;$90
  2879.         dc.l    STAIndY
  2880.         dc.l    IllegalOp
  2881.         dc.l    SHAIndY        ;*
  2882.         dc.l    STYZeroX
  2883.         dc.l    STAZeroX
  2884.         dc.l    STXZeroY
  2885.         dc.l    SAXZeroY    ;*
  2886.  
  2887.         dc.l    TYA        ;$98
  2888.         dc.l    STAAbsY
  2889.         dc.l    TXS
  2890.         dc.l    SHSAbsY        ;*
  2891.         dc.l    SHYAbsX        ;*
  2892.         dc.l    STAAbsX
  2893.         dc.l    SHXAbsY        ;*
  2894.         dc.l    SHAAbsY        ;*
  2895.  
  2896.         dc.l    LDYImm        ;$a0
  2897.         dc.l    LDAIndX
  2898.         dc.l    LDXImm
  2899.         dc.l    LAXIndX        ;*
  2900.         dc.l    LDYZero
  2901.         dc.l    LDAZero
  2902.         dc.l    LDXZero
  2903.         dc.l    LAXZero        ;*
  2904.  
  2905.         dc.l    TAY        ;$a8
  2906.         dc.l    LDAImm
  2907.         dc.l    TAX
  2908.         dc.l    LXAImm        ;*
  2909.         dc.l    LDYAbs
  2910.         dc.l    LDAAbs
  2911.         dc.l    LDXAbs
  2912.         dc.l    LAXAbs        ;*
  2913.  
  2914.         dc.l    BCSRel        ;$b0
  2915.         dc.l    LDAIndY
  2916.         dc.l    IllegalOp
  2917.         dc.l    LAXIndY        ;*
  2918.         dc.l    LDYZeroX
  2919.         dc.l    LDAZeroX
  2920.         dc.l    LDXZeroY
  2921.         dc.l    LAXZeroY    ;*
  2922.  
  2923.         dc.l    CLV        ;$b8
  2924.         dc.l    LDAAbsY
  2925.         dc.l    TSX
  2926.         dc.l    LASAbsY        ;*
  2927.         dc.l    LDYAbsX
  2928.         dc.l    LDAAbsX
  2929.         dc.l    LDXAbsY
  2930.         dc.l    LAXAbsY        ;*
  2931.  
  2932.         dc.l    CPYImm        ;$c0
  2933.         dc.l    CMPIndX
  2934.         dc.l    NOPZero        ;*
  2935.         dc.l    DCPIndX        ;*
  2936.         dc.l    CPYZero
  2937.         dc.l    CMPZero
  2938.         dc.l    DECZero
  2939.         dc.l    DCPZero        ;*
  2940.  
  2941.         dc.l    INY        ;$c8
  2942.         dc.l    CMPImm
  2943.         dc.l    DEX
  2944.         dc.l    SBXImm        ;*
  2945.         dc.l    CPYAbs
  2946.         dc.l    CMPAbs
  2947.         dc.l    DECAbs
  2948.         dc.l    DCPAbs        ;*
  2949.  
  2950.         dc.l    BNERel        ;$d0
  2951.         dc.l    CMPIndY
  2952.         dc.l    IllegalOp
  2953.         dc.l    DCPIndY        ;*
  2954.         dc.l    NOPZeroX    ;*
  2955.         dc.l    CMPZeroX
  2956.         dc.l    DECZeroX
  2957.         dc.l    DCPZeroX    ;*
  2958.  
  2959.         dc.l    CLD        ;$d8
  2960.         dc.l    CMPAbsY
  2961.         dc.l    NOPImpl        ;*
  2962.         dc.l    DCPAbsY        ;*
  2963.         dc.l    NOPAbsX        ;*
  2964.         dc.l    CMPAbsX
  2965.         dc.l    DECAbsX
  2966.         dc.l    DCPAbsX        ;*
  2967.  
  2968.         dc.l    CPXImm        ;$e0
  2969.         dc.l    SBCIndX
  2970.         dc.l    NOPZero        ;*
  2971.         dc.l    ISBIndX        ;*
  2972.         dc.l    CPXZero
  2973.         dc.l    SBCZero
  2974.         dc.l    INCZero
  2975.         dc.l    ISBZero        ;*
  2976.  
  2977.         dc.l    INX        ;$e8
  2978.         dc.l    SBCImm
  2979.         dc.l    NOPImpl
  2980.         dc.l    SBCImm        ;*
  2981.         dc.l    CPXAbs
  2982.         dc.l    SBCAbs
  2983.         dc.l    INCAbs
  2984.         dc.l    ISBAbs        ;*
  2985.  
  2986.         dc.l    BEQRel        ;$f0
  2987.         dc.l    SBCIndY
  2988.         dc.l    OpIEC        ;Patch
  2989.         dc.l    ISBIndY        ;*
  2990.         dc.l    NOPZeroX    ;*
  2991.         dc.l    SBCZeroX
  2992.         dc.l    INCZeroX
  2993.         dc.l    ISBZeroX    ;*
  2994.  
  2995.         dc.l    SED        ;$f8
  2996.         dc.l    SBCAbsY
  2997.         dc.l    NOPImpl        ;*
  2998.         dc.l    ISBAbsY        ;*
  2999.         dc.l    NOPAbsX        ;*
  3000.         dc.l    SBCAbsX
  3001.         dc.l    INCAbsX
  3002.         dc.l    ISBAbsX        ;*
  3003.  
  3004.  
  3005. **
  3006. ** Datenbereich
  3007. **
  3008.  
  3009. ; 6510-Task
  3010. CPUProc        dc.l    0    ;Prozess-Handle
  3011. CPUTask        dc.l    0    ;Task des Prozesses
  3012. ReadySet    dc.l    0    ;Signal des Hauptprogramms
  3013. ReadySig    dc.w    0
  3014. DontPause    dc.w    0    ;#0: Task darf nicht angehalten werden
  3015.  
  3016. ; Emulator-Kennung
  3017. DFFFByte    dc.b    $55    ;Wechselt bei jedem Lesen zwischen $55 und $aa
  3018.  
  3019. ; Interrupt-Flags. Bei einem Interrupt wird eins dieser Flags gesetzt.
  3020. ; Das bewirkt, daß nach dem nächsten Periodic der 6510-Task in die
  3021. ; Routine "HandleInt" springt. Dort werden diese Flags ausgewertet und
  3022. ; entsprechend verzweigt.
  3023.         CNOP    0,4
  3024. Interrupt            ;Zusammenfassung als Langwort
  3025. IntIsRESET    dc.b    0    ;RESET aufgetreten oder 6510 beenden
  3026. IntIsNMI    dc.b    0    ;NMI aufgetreten
  3027. IntIsIRQ            ;Zusammenfassung als Wort
  3028. IntIsVICIRQ    dc.b    0    ;IRQ durch VIC aufgetreten
  3029. IntIsCIAIRQ    dc.b    0    ;IRQ durch CIA-A aufgetreten
  3030.  
  3031. RESETIsEXIT    dc.b    0    ;Zu Unterscheidung von RESET und EXIT
  3032.  
  3033.         CNOP    0,4
  3034. RegStore    ds.l    6
  3035.  
  3036. ; Speicherzeiger (außer bei TheChar stimmt bei allen das untere Wort
  3037. ; mit der tatsächlichen C64-Adresse überein, also
  3038. ;  TheRAM   : xxxx0000
  3039. ;  TheBasic : xxxxa000
  3040. ;  TheKernal: xxxxe000
  3041. ;  TheColor : xxxxd800
  3042.         CNOP    0,4
  3043. TheRAM        dc.l    0    ;Zeiger auf C64-RAM (64K)
  3044. TheBasic    dc.l    0    ;Zeiger auf Basic-ROM
  3045. TheKernal    dc.l    0    ;Zeiger auf Kernal-ROM
  3046. TheChar        dc.l    0    ;Zeiger auf Char-ROM
  3047. TheColor    dc.l    0    ;Zeiger auf Farb-RAM
  3048.  
  3049. ; Taglist für CreateNewProc
  3050. ProcTags    dc.l    NP_Entry,CPUTaskProc
  3051.         dc.l    NP_Name,CPUTaskName
  3052.         dc.l    NP_Priority,-1
  3053.         dc.l    0,0
  3054.  
  3055. ; Requester
  3056. IllegalOpReq    dc.l    20,0,0,0,0
  3057. JumpToIOReq    dc.l    20,0,0,0,0
  3058.  
  3059. RequestStream    ds.l    16    ;Argumente
  3060.  
  3061.         SECTION    "BSS",BSS
  3062.  
  3063. ; Sprungtabellen für Speicherzugriff: Ein Eintrag pro Seite
  3064. ; Eine Tabelle für jede der 8 Speicherkonfigurationen
  3065. ReadTab0    ds.l    256
  3066. ReadTab1    ds.l    256
  3067. ReadTab2    ds.l    256
  3068. ReadTab3    ds.l    256
  3069. ReadTab4    ds.l    256
  3070. ReadTab5    ds.l    256
  3071. ReadTab6    ds.l    256
  3072. ReadTab7    ds.l    256
  3073.  
  3074. WriteTab0    ds.l    256
  3075. WriteTab1    ds.l    256
  3076. WriteTab2    ds.l    256
  3077. WriteTab3    ds.l    256
  3078. WriteTab4    ds.l    256
  3079. WriteTab5    ds.l    256
  3080. WriteTab6    ds.l    256
  3081. WriteTab7    ds.l    256
  3082.  
  3083. JumpTab0    ds.l    256
  3084. JumpTab1    ds.l    256
  3085. JumpTab2    ds.l    256
  3086. JumpTab3    ds.l    256
  3087. JumpTab4    ds.l    256
  3088. JumpTab5    ds.l    256
  3089. JumpTab6    ds.l    256
  3090. JumpTab7    ds.l    256
  3091.  
  3092.         END
  3093.